@durable-streams/cli 0.1.0

package/README.md

@@ -0,0 +1,132 @@
+# Durable Streams CLI
+
+A command-line tool for interacting with durable streams.
+
+## Installation
+
+### Local Development
+
+```bash
+# Install dependencies
+pnpm install
+
+# Build the CLI (for production bin)
+pnpm build
+```
+
+### Global Installation for Development
+
+For development, you can link the CLI globally with live TypeScript execution (no rebuild needed):
+
+```bash
+# From the CLI package directory
+pnpm link:dev
+
+# Now you can use durable-stream-dev anywhere
+# Changes to src/index.ts are immediately available
+durable-stream-dev create my-stream
+```
+
+This uses `tsx` to run the TypeScript source directly, so you see changes immediately without rebuilding.
+
+## Quick Start
+
+The easiest way to get started is to run the local development server and use the CLI:
+
+### Terminal 1: Start the local server
+
+```bash
+pnpm start:dev
+```
+
+This will start a Durable Streams server at `http://localhost:4437` with live reloading.
+
+### Terminal 2: Use the CLI
+
+```bash
+# Set the server URL (optional, defaults to http://localhost:4437)
+export STREAM_URL=http://localhost:4437
+
+# Create a stream
+durable-stream-dev create my-stream
+
+# Write to the stream
+durable-stream-dev write my-stream "Hello, world!"
+
+# Read from the stream (follows live)
+durable-stream-dev read my-stream
+```
+
+## Usage
+
+### Environment Variables
+
+- `STREAM_URL` - Base URL of the stream server (default: `http://localhost:4437`)
+
+### Commands
+
+#### Create a stream
+
+```bash
+durable-stream-dev create <stream_id>
+```
+
+#### Write to a stream
+
+```bash
+# Write content as arguments
+durable-stream-dev write <stream_id> "Hello, world!"
+
+# Pipe content from stdin
+echo "Hello from stdin" | durable-stream-dev write <stream_id>
+cat file.txt | durable-stream-dev write <stream_id>
+```
+
+#### Read from a stream
+
+```bash
+# Follows the stream and outputs new data to stdout
+durable-stream-dev read <stream_id>
+```
+
+#### Delete a stream
+
+```bash
+durable-stream-dev delete <stream_id>
+```
+
+## Complete Example Workflow
+
+```bash
+# Terminal 1: Start the local development server
+pnpm start:dev
+
+# Terminal 2: Set up the stream
+export STREAM_URL=http://localhost:4437
+durable-stream-dev create test-stream
+
+# Terminal 3: Start reading (will show data as it arrives)
+export STREAM_URL=http://localhost:4437
+durable-stream-dev read test-stream
+
+# Back in Terminal 2: Write data and watch it appear in Terminal 3
+durable-stream-dev write test-stream "First message"
+durable-stream-dev write test-stream "Second message"
+echo "Piped content!" | durable-stream-dev write test-stream
+```
+
+## Development
+
+```bash
+# Start the example server with live reloading
+pnpm start:dev
+
+# Watch mode for CLI development (rebuilds dist/)
+pnpm dev
+
+# Build
+pnpm build
+
+# Link globally for development (uses tsx, no rebuild needed)
+pnpm link:dev
+```

package/bin/durable-stream-dev.mjs

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+
+/* eslint-disable stylistic/quotes */
+
+/**
+ * Development wrapper that uses tsx to run the TypeScript source directly.
+ * This allows you to use `pnpm link --global` and see changes immediately
+ * without rebuilding.
+ */
+
+import { spawn } from "node:child_process"
+import { fileURLToPath } from "node:url"
+import { dirname, join } from "node:path"
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+const srcPath = join(__dirname, "..", "src", "index.ts")
+
+// Run tsx with the source file
+const child = spawn("tsx", [srcPath, ...process.argv.slice(2)], {
+  stdio: "inherit",
+})
+
+child.on("exit", (code) => {
+  process.exit(code ?? 0)
+})

package/dist/index.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+import { stderr, stdin, stdout } from "node:process";
+import { DurableStream } from "@durable-streams/client";
+
+//#region src/index.ts
+const STREAM_URL = process.env.STREAM_URL || `http://localhost:4437`;
+function printUsage() {
+	console.error(`
+Usage:
+  durable-stream create <stream_id>              Create a new stream
+  durable-stream write <stream_id> <content>     Write content to a stream
+  cat file.txt | durable-stream write <stream_id>    Write stdin to a stream
+  durable-stream read <stream_id>                Follow a stream and write to stdout
+  durable-stream delete <stream_id>              Delete a stream
+
+Environment Variables:
+  STREAM_URL    Base URL of the stream server (default: http://localhost:4437)
+`);
+}
+async function createStream(streamId) {
+	const url = `${STREAM_URL}/v1/stream/${streamId}`;
+	try {
+		await DurableStream.create({
+			url,
+			contentType: `application/octet-stream`
+		});
+		console.log(`Created stream: ${streamId}`);
+	} catch (error) {
+		if (error instanceof Error) stderr.write(`Error creating stream: ${error.message}\n`);
+		process.exit(1);
+	}
+}
+async function writeStream(streamId, content) {
+	const url = `${STREAM_URL}/v1/stream/${streamId}`;
+	try {
+		const stream = new DurableStream({ url });
+		if (content) {
+			const processedContent = content.replace(/\\n/g, `\n`).replace(/\\t/g, `\t`).replace(/\\r/g, `\r`).replace(/\\\\/g, `\\`);
+			await stream.append(processedContent);
+			console.log(`Wrote ${processedContent.length} bytes to ${streamId}`);
+		} else {
+			const chunks = [];
+			stdin.on(`data`, (chunk) => {
+				chunks.push(chunk);
+			});
+			await new Promise((resolve, reject) => {
+				stdin.on(`end`, resolve);
+				stdin.on(`error`, reject);
+			});
+			const data = Buffer.concat(chunks);
+			await stream.append(data);
+			console.log(`Wrote ${data.length} bytes to ${streamId}`);
+		}
+	} catch (error) {
+		if (error instanceof Error) stderr.write(`Error writing to stream: ${error.message}\n`);
+		process.exit(1);
+	}
+}
+async function readStream(streamId) {
+	const url = `${STREAM_URL}/v1/stream/${streamId}`;
+	try {
+		const stream = new DurableStream({ url });
+		const res = await stream.stream({ live: `auto` });
+		for await (const chunk of res.bodyStream()) if (chunk.length > 0) stdout.write(chunk);
+	} catch (error) {
+		if (error instanceof Error) stderr.write(`Error reading stream: ${error.message}\n`);
+		process.exit(1);
+	}
+}
+async function deleteStream(streamId) {
+	const url = `${STREAM_URL}/v1/stream/${streamId}`;
+	try {
+		const stream = new DurableStream({ url });
+		await stream.delete();
+		console.log(`Deleted stream: ${streamId}`);
+	} catch (error) {
+		if (error instanceof Error) stderr.write(`Error deleting stream: ${error.message}\n`);
+		process.exit(1);
+	}
+}
+async function main() {
+	const args = process.argv.slice(2);
+	if (args.length < 1) {
+		printUsage();
+		process.exit(1);
+	}
+	const command = args[0];
+	switch (command) {
+		case `create`: {
+			if (args.length < 2) {
+				stderr.write(`Error: stream_id required\n`);
+				printUsage();
+				process.exit(1);
+			}
+			await createStream(args[1]);
+			break;
+		}
+		case `write`: {
+			if (args.length < 2) {
+				stderr.write(`Error: stream_id required\n`);
+				printUsage();
+				process.exit(1);
+			}
+			const streamId = args[1];
+			const content = args.slice(2).join(` `);
+			if (!stdin.isTTY) await writeStream(streamId);
+			else if (content) await writeStream(streamId, content);
+			else {
+				stderr.write(`Error: content required (provide as argument or pipe to stdin)\n`);
+				printUsage();
+				process.exit(1);
+			}
+			break;
+		}
+		case `read`: {
+			if (args.length < 2) {
+				stderr.write(`Error: stream_id required\n`);
+				printUsage();
+				process.exit(1);
+			}
+			await readStream(args[1]);
+			break;
+		}
+		case `delete`: {
+			if (args.length < 2) {
+				stderr.write(`Error: stream_id required\n`);
+				printUsage();
+				process.exit(1);
+			}
+			await deleteStream(args[1]);
+			break;
+		}
+		default:
+			stderr.write(`Error: unknown command '${command}'\n`);
+			printUsage();
+			process.exit(1);
+	}
+}
+main().catch((error) => {
+	stderr.write(`Fatal error: ${error.message}\n`);
+	process.exit(1);
+});
+
+//#endregion

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@durable-streams/cli",
+  "version": "0.1.0",
+  "description": "CLI tool for working with Durable Streams",
+  "author": "Durable Stream contributors",
+  "license": "Apache-2.0",
+  "type": "module",
+  "bin": {
+    "durable-stream": "./dist/index.js",
+    "durable-stream-dev": "./bin/durable-stream-dev.mjs"
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "start:dev": "tsx --watch example-server.ts",
+    "link:dev": "pnpm link --global"
+  },
+  "dependencies": {
+    "@durable-streams/client": "workspace:*"
+  },
+  "devDependencies": {
+    "@durable-streams/server": "workspace:*",
+    "@types/node": "^22.15.21",
+    "tsdown": "^0.9.0",
+    "tsx": "^4.19.2",
+    "typescript": "^5.5.2"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}