clawdepl 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 clawdepl
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,50 @@
+# clawdepl
+
+Create and manage OpenClaw AI Agent orchestrator instances from the command line.
+
+This is the npm distribution of clawdepl. For full documentation, see the [main repository](https://github.com/clawdepl/clawdepl).
+
+## Quick Start (No Install)
+
+```bash
+npx clawdepl init my-project
+```
+
+## Installation
+
+```bash
+npm install -g clawdepl
+```
+
+## Usage
+
+```bash
+# Create a new OpenClaw project
+clawdepl init my-project
+
+# Deploy to hosted infrastructure
+clawdepl deploy
+
+# Check instance status
+clawdepl status
+
+# Get help
+clawdepl --help
+```
+
+## How It Works
+
+This package is a thin wrapper around the clawdepl Go binary. On installation, it automatically downloads the appropriate binary for your platform from GitHub Releases.
+
+Supported platforms:
+- Linux (x64, arm64)
+- macOS (x64, arm64)
+- Windows (x64, arm64)
+
+## Environment Variables
+
+- `CLAWDEPL_BINARY_PATH`: Override the path to the clawdepl binary
+
+## License
+
+MIT - see [LICENSE](https://github.com/clawdepl/clawdepl/blob/main/LICENSE)

package/bin/clawdepl.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+
+const { spawn } = require("child_process");
+const path = require("path");
+const os = require("os");
+const fs = require("fs");
+
+/**
+ * Get the path to the clawdepl binary for the current platform
+ */
+function getBinaryPath() {
+  const platform = os.platform();
+  let binaryName = "clawdepl";
+  if (platform === "win32") {
+    binaryName += ".exe";
+  }
+
+  // 1. Check for binary in the same directory as this script (installed by postinstall)
+  const localBinary = path.join(__dirname, binaryName);
+  if (fs.existsSync(localBinary)) {
+    return localBinary;
+  }
+
+  // 2. Check for development binary in project root
+  const devBinary = path.join(__dirname, "..", "..", binaryName);
+  if (fs.existsSync(devBinary)) {
+    return devBinary;
+  }
+
+  // 3. Check for binary via CLAWDEPL_BINARY_PATH env var (useful for testing)
+  if (process.env.CLAWDEPL_BINARY_PATH && fs.existsSync(process.env.CLAWDEPL_BINARY_PATH)) {
+    return process.env.CLAWDEPL_BINARY_PATH;
+  }
+
+  // 4. Fall back to PATH lookup
+  return binaryName;
+}
+
+/**
+ * Run the clawdepl binary with the provided arguments
+ */
+function run() {
+  const binaryPath = getBinaryPath();
+  const args = process.argv.slice(2);
+
+  const child = spawn(binaryPath, args, {
+    stdio: "inherit",
+    shell: process.platform === "win32",
+  });
+
+  child.on("error", (err) => {
+    if (err.code === "ENOENT") {
+      console.error("Error: clawdepl binary not found.");
+      console.error("");
+      console.error("The binary was not bundled with this package and is not in your PATH.");
+      console.error("");
+      console.error("Install the binary using one of these methods:");
+      console.error("");
+      console.error("  # Install from source (requires Go 1.21+):");
+      console.error("  go install github.com/clawdepl/clawdepl@latest");
+      console.error("");
+      console.error("  # Or set CLAWDEPL_BINARY_PATH to point to the binary:");
+      console.error("  export CLAWDEPL_BINARY_PATH=/path/to/clawdepl");
+      console.error("");
+      process.exit(1);
+    }
+    console.error("Error running clawdepl:", err.message);
+    process.exit(1);
+  });
+
+  child.on("close", (code) => {
+    process.exit(code ?? 0);
+  });
+}
+
+run();

package/bin/install.js

@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+
+const https = require("https");
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const { execSync, spawn } = require("child_process");
+const zlib = require("zlib");
+
+const VERSION = require("../package.json").version;
+const REPO = "clawdepl/clawdepl";
+
+/**
+ * Get platform-specific binary info
+ */
+function getPlatformInfo() {
+  const platform = os.platform();
+  const arch = os.arch();
+
+  const platformMap = {
+    darwin: "darwin",
+    linux: "linux",
+    win32: "windows",
+  };
+
+  const archMap = {
+    x64: "amd64",
+    arm64: "arm64",
+  };
+
+  const osPlatform = platformMap[platform];
+  const osArch = archMap[arch];
+
+  if (!osPlatform || !osArch) {
+    throw new Error(`Unsupported platform: ${platform}-${arch}`);
+  }
+
+  const ext = platform === "win32" ? ".exe" : "";
+  const binaryName = `clawdepl${ext}`;
+  const archiveName = `clawdepl_${VERSION}_${osPlatform}_${osArch}.tar.gz`;
+
+  return { platform: osPlatform, arch: osArch, binaryName, archiveName, ext };
+}
+
+/**
+ * Follow redirects and download file
+ */
+function downloadFile(url) {
+  return new Promise((resolve, reject) => {
+    const makeRequest = (currentUrl, redirectCount = 0) => {
+      if (redirectCount > 10) {
+        reject(new Error("Too many redirects"));
+        return;
+      }
+
+      const protocol = currentUrl.startsWith("https") ? https : require("http");
+      
+      protocol.get(currentUrl, {
+        headers: {
+          "User-Agent": "clawdepl-npm-installer",
+          "Accept": "application/octet-stream",
+        }
+      }, (response) => {
+        if (response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
+          makeRequest(response.headers.location, redirectCount + 1);
+          return;
+        }
+
+        if (response.statusCode !== 200) {
+          reject(new Error(`Download failed with status ${response.statusCode}`));
+          return;
+        }
+
+        const chunks = [];
+        response.on("data", (chunk) => chunks.push(chunk));
+        response.on("end", () => resolve(Buffer.concat(chunks)));
+        response.on("error", reject);
+      }).on("error", reject);
+    };
+
+    makeRequest(url);
+  });
+}
+
+/**
+ * Extract tar.gz archive
+ */
+async function extractTarGz(buffer, destDir, binaryName) {
+  const tar = require("tar");
+  const tmpFile = path.join(os.tmpdir(), `clawdepl-${Date.now()}.tar.gz`);
+  
+  fs.writeFileSync(tmpFile, buffer);
+  
+  try {
+    await tar.extract({
+      file: tmpFile,
+      cwd: destDir,
+      filter: (p) => p === binaryName || p.endsWith(`/${binaryName}`),
+    });
+  } finally {
+    fs.unlinkSync(tmpFile);
+  }
+}
+
+/**
+ * Simple tar extraction without external dependency
+ */
+function extractTarGzSimple(buffer, destDir, binaryName) {
+  return new Promise((resolve, reject) => {
+    const gunzip = zlib.createGunzip();
+    const chunks = [];
+    
+    gunzip.on("data", (chunk) => chunks.push(chunk));
+    gunzip.on("end", () => {
+      const tarData = Buffer.concat(chunks);
+      
+      // Simple tar parsing - find the binary file
+      let offset = 0;
+      while (offset < tarData.length) {
+        // Read header (512 bytes)
+        const header = tarData.slice(offset, offset + 512);
+        if (header[0] === 0) break; // End of archive
+        
+        // Get filename (first 100 bytes, null-terminated)
+        let nameEnd = 0;
+        while (nameEnd < 100 && header[nameEnd] !== 0) nameEnd++;
+        const name = header.slice(0, nameEnd).toString("utf8");
+        
+        // Get file size (octal, bytes 124-135)
+        const sizeStr = header.slice(124, 136).toString("utf8").trim();
+        const size = parseInt(sizeStr, 8) || 0;
+        
+        offset += 512; // Move past header
+        
+        // Check if this is our binary
+        if (name === binaryName || name.endsWith(`/${binaryName}`)) {
+          const fileData = tarData.slice(offset, offset + size);
+          const destPath = path.join(destDir, binaryName);
+          fs.writeFileSync(destPath, fileData);
+          fs.chmodSync(destPath, 0o755);
+          resolve(destPath);
+          return;
+        }
+        
+        // Move to next file (size rounded up to 512-byte boundary)
+        offset += Math.ceil(size / 512) * 512;
+      }
+      
+      reject(new Error(`Binary ${binaryName} not found in archive`));
+    });
+    gunzip.on("error", reject);
+    
+    gunzip.end(buffer);
+  });
+}
+
+/**
+ * Download and install the binary
+ */
+async function downloadBinary() {
+  const { binaryName, archiveName } = getPlatformInfo();
+  const binDir = __dirname;
+  const binaryPath = path.join(binDir, binaryName);
+
+  // Skip if binary already exists
+  if (fs.existsSync(binaryPath)) {
+    console.log("clawdepl binary already installed.");
+    return;
+  }
+
+  // Check for local development binary (in project root)
+  const devBinary = path.join(__dirname, "..", "..", binaryName);
+  if (fs.existsSync(devBinary)) {
+    console.log("Using local development binary.");
+    fs.copyFileSync(devBinary, binaryPath);
+    fs.chmodSync(binaryPath, 0o755);
+    return;
+  }
+
+  const downloadUrl = `https://github.com/${REPO}/releases/download/v${VERSION}/${archiveName}`;
+  
+  console.log(`Downloading clawdepl v${VERSION}...`);
+  console.log(`Platform: ${os.platform()}-${os.arch()}`);
+  console.log(`URL: ${downloadUrl}`);
+
+  try {
+    const buffer = await downloadFile(downloadUrl);
+    console.log(`Downloaded ${buffer.length} bytes, extracting...`);
+    
+    await extractTarGzSimple(buffer, binDir, binaryName);
+    
+    console.log(`Successfully installed clawdepl to ${binaryPath}`);
+  } catch (err) {
+    console.warn("");
+    console.warn(`Note: Could not download pre-built binary: ${err.message}`);
+    console.warn("");
+    console.warn("This is expected if:");
+    console.warn("  - This version hasn't been released yet");
+    console.warn("  - You're on an unsupported platform");
+    console.warn("");
+    console.warn("The CLI will look for 'clawdepl' in your PATH at runtime.");
+    console.warn("Install from source: go install github.com/clawdepl/clawdepl@latest");
+    console.warn("");
+    // Don't fail the install - the wrapper will handle missing binary at runtime
+  }
+}
+
+downloadBinary().catch((err) => {
+  console.error("Installation warning:", err.message);
+  // Exit 0 to not fail npm install - wrapper handles missing binary gracefully
+  process.exit(0);
+});

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "clawdepl",
+  "version": "0.0.1",
+  "description": "Create and manage OpenClaw AI Agent orchestrator instances",
+  "bin": {
+    "clawdepl": "./bin/clawdepl.js"
+  },
+  "scripts": {
+    "postinstall": "node ./bin/install.js",
+    "test": "node ./bin/clawdepl.js --version"
+  },
+  "keywords": [
+    "openclaw",
+    "ai",
+    "agents",
+    "orchestrator",
+    "cli",
+    "clawdepl",
+    "clawdepl"
+  ],
+  "author": "clawdepl",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/clawdepl/clawdepl.git"
+  },
+  "bugs": {
+    "url": "https://github.com/clawdepl/clawdepl/issues"
+  },
+  "homepage": "https://github.com/clawdepl/clawdepl#readme",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
+  "files": [
+    "bin/",
+    "README.md",
+    "LICENSE"
+  ],
+  "preferGlobal": true
+}