@durable-streams/cli 0.1.1 → 0.1.3

package/README.md

@@ -4,31 +4,38 @@ A command-line tool for interacting with durable streams.
 
 ## Installation
 
-### Local Development
+### From npm
 
 ```bash
-# Install dependencies
-pnpm install
+# Global installation
+npm install -g @durable-streams/cli
 
-# Build the CLI (for production bin)
-pnpm build
+# Or run directly with npx
+npx @durable-streams/cli create my-stream
+npx @durable-streams/cli read my-stream
 ```
 
-### Global Installation for Development
-
-For development, you can link the CLI globally with live TypeScript execution (no rebuild needed):
+### From source (for development)
 
 ```bash
-# From the CLI package directory
+# Clone the repository
+git clone https://github.com/durable-streams/durable-streams.git
+cd durable-streams
+
+# Install dependencies
+pnpm install
+
+# Build the CLI
+pnpm build
+
+# Link globally for development (uses tsx, no rebuild needed)
+cd packages/cli
 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:

package/dist/index.cjs

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+"use strict";
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const node_process = __toESM(require("node:process"));
+const __durable_streams_client = __toESM(require("@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 __durable_streams_client.DurableStream.create({
+			url,
+			contentType: `application/octet-stream`
+		});
+		console.log(`Created stream: ${streamId}`);
+	} catch (error) {
+		if (error instanceof Error) node_process.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 __durable_streams_client.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 = [];
+			node_process.stdin.on(`data`, (chunk) => {
+				chunks.push(chunk);
+			});
+			await new Promise((resolve, reject) => {
+				node_process.stdin.on(`end`, resolve);
+				node_process.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) node_process.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 __durable_streams_client.DurableStream({ url });
+		const res = await stream.stream({ live: `auto` });
+		for await (const chunk of res.bodyStream()) if (chunk.length > 0) node_process.stdout.write(chunk);
+	} catch (error) {
+		if (error instanceof Error) node_process.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 __durable_streams_client.DurableStream({ url });
+		await stream.delete();
+		console.log(`Deleted stream: ${streamId}`);
+	} catch (error) {
+		if (error instanceof Error) node_process.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) {
+				node_process.stderr.write(`Error: stream_id required\n`);
+				printUsage();
+				process.exit(1);
+			}
+			await createStream(args[1]);
+			break;
+		}
+		case `write`: {
+			if (args.length < 2) {
+				node_process.stderr.write(`Error: stream_id required\n`);
+				printUsage();
+				process.exit(1);
+			}
+			const streamId = args[1];
+			const content = args.slice(2).join(` `);
+			if (!node_process.stdin.isTTY) await writeStream(streamId);
+			else if (content) await writeStream(streamId, content);
+			else {
+				node_process.stderr.write(`Error: content required (provide as argument or pipe to stdin)\n`);
+				printUsage();
+				process.exit(1);
+			}
+			break;
+		}
+		case `read`: {
+			if (args.length < 2) {
+				node_process.stderr.write(`Error: stream_id required\n`);
+				printUsage();
+				process.exit(1);
+			}
+			await readStream(args[1]);
+			break;
+		}
+		case `delete`: {
+			if (args.length < 2) {
+				node_process.stderr.write(`Error: stream_id required\n`);
+				printUsage();
+				process.exit(1);
+			}
+			await deleteStream(args[1]);
+			break;
+		}
+		default:
+			node_process.stderr.write(`Error: unknown command '${command}'\n`);
+			printUsage();
+			process.exit(1);
+	}
+}
+main().catch((error) => {
+	node_process.stderr.write(`Fatal error: ${error.message}\n`);
+	process.exit(1);
+});
+
+//#endregion

package/dist/index.d.cts

@@ -0,0 +1 @@
+export { };

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { };

package/package.json

@@ -1,46 +1,63 @@
 {
   "name": "@durable-streams/cli",
   "description": "CLI tool for working with Durable Streams",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "author": "Durable Stream contributors",
-  "license": "Apache-2.0",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/durable-streams/durable-streams.git",
-    "directory": "packages/cli"
-  },
-  "bugs": {
-    "url": "https://github.com/durable-streams/durable-streams/issues"
-  },
-  "keywords": [
-    "durable-streams",
-    "streaming",
-    "cli",
-    "typescript"
-  ],
   "bin": {
+    "cli": "./dist/index.js",
     "durable-stream": "./dist/index.js",
     "durable-stream-dev": "./bin/durable-stream-dev.mjs"
   },
+  "bugs": {
+    "url": "https://github.com/durable-streams/durable-streams/issues"
+  },
   "dependencies": {
-    "@durable-streams/client": "0.1.1"
+    "@durable-streams/client": "0.1.2"
   },
   "devDependencies": {
     "@types/node": "^22.15.21",
     "tsdown": "^0.9.0",
     "tsx": "^4.19.2",
     "typescript": "^5.5.2",
-    "@durable-streams/server": "0.1.1"
+    "@durable-streams/server": "0.1.3"
   },
   "engines": {
     "node": ">=18.0.0"
   },
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
   "files": [
     "dist",
     "bin"
   ],
-  "main": "./dist/index.js",
+  "keywords": [
+    "cli",
+    "durable-streams",
+    "streaming",
+    "typescript"
+  ],
+  "license": "Apache-2.0",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/durable-streams/durable-streams.git",
+    "directory": "packages/cli"
+  },
+  "sideEffects": false,
   "type": "module",
+  "types": "./dist/index.d.ts",
   "scripts": {
     "build": "tsdown",
     "dev": "tsdown --watch",