cawide 0.4.4

package/README.md

@@ -0,0 +1,66 @@
+# Cawide
+
+The official npm launcher for the Cawide desktop companion daemon. It runs a local development build when used from the Cawide repository; otherwise it downloads the matching Cawide release binary and caches it for later runs.
+
+## Quick start
+
+Run Cawide without installing it globally:
+
+```sh
+npx cawide start
+```
+
+Or install the command globally:
+
+```sh
+npm install -g cawide
+cawide start
+```
+
+All arguments are forwarded to the native Cawide CLI. Common commands include:
+
+```sh
+cawide --help
+cawide start --help
+cawide status
+cawide qr
+cawide logs
+cawide stop
+```
+
+Use `cawide <command> --help` for the options supported by a particular command.
+
+## Supported platforms
+
+- macOS on Apple Silicon and Intel
+- Linux on x64 and ARM64
+- Windows on x64 and ARM64
+
+On first use, the launcher downloads the binary for the current platform from the matching [GitHub release](https://github.com/longd2k3/cawide/releases). The binary is cached at:
+
+- macOS and Linux: `~/.cache/cawide/bin/v0.4.4/cawide`
+- Windows: `%LOCALAPPDATA%\cawide\bin\v0.4.4\cawide.exe`
+
+## Troubleshooting
+
+### The download fails
+
+Check that GitHub Releases is reachable from your network and that release `v0.4.4` contains an artifact for your platform. A proxy or firewall may block redirected downloads from GitHub's asset host.
+
+### The cached binary is damaged
+
+Remove the versioned cache directory shown above and run the command again. Cawide will download a fresh copy.
+
+### Permission denied on macOS or Linux
+
+The launcher makes the downloaded binary executable automatically. If the cache was copied from another machine, remove it and rerun Cawide so it can be recreated with the correct permissions.
+
+### macOS blocks the binary
+
+Open **System Settings → Privacy & Security** and allow Cawide if macOS reports that it blocked the downloaded application. Only use binaries from the official Cawide GitHub release.
+
+### Show available commands
+
+```sh
+cawide --help
+```

package/bin/cawide.js

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+const https = require("node:https");
+const childProcess = require("node:child_process");
+const zlib = require("node:zlib");
+
+const VERSION = "0.4.4";
+const RELEASE_BASE = `https://github.com/longd2k3/cawide/releases/download/v${VERSION}`;
+const TARGETS = {
+  "darwin-arm64": ["aarch64-apple-darwin"],
+  "darwin-x64": ["x86_64-apple-darwin", "aarch64-apple-darwin"],
+  "linux-x64": ["x86_64-unknown-linux-gnu"],
+  "linux-arm64": ["aarch64-unknown-linux-gnu"],
+  "win32-x64": ["x86_64-pc-windows-msvc"],
+  "win32-arm64": ["aarch64-pc-windows-msvc"],
+};
+const SIGNAL_EXIT_CODES = { SIGINT: 130, SIGTERM: 143 };
+
+function executableName() {
+  return process.platform === "win32" ? "cawide.exe" : "cawide";
+}
+
+function localBinary() {
+  const repositoryRoot = path.resolve(__dirname, "../../..");
+  if (!fs.existsSync(path.join(repositoryRoot, "Cargo.toml"))) return null;
+
+  for (const profile of ["release", "debug"]) {
+    const candidate = path.join(repositoryRoot, "target", profile, executableName());
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+
+function cacheBinary() {
+  const cacheRoot =
+    process.platform === "win32"
+      ? process.env.LOCALAPPDATA || path.join(os.homedir(), "AppData", "Local")
+      : path.join(os.homedir(), ".cache");
+  return path.join(cacheRoot, "cawide", "bin", `v${VERSION}`, executableName());
+}
+
+function platformTargets() {
+  const targets = TARGETS[`${process.platform}-${process.arch}`];
+  if (!targets) {
+    throw new Error(
+      `Cawide does not provide a binary for ${process.platform}/${process.arch}. Supported platforms: macOS (arm64, x64), Linux (arm64, x64), and Windows (arm64, x64).`
+    );
+  }
+  return targets;
+}
+
+function download(url, redirectsLeft = 5) {
+  return new Promise((resolve, reject) => {
+    const request = https.get(
+      url,
+      { headers: { "User-Agent": `cawide-npm/${VERSION}` } },
+      (response) => {
+        const status = response.statusCode || 0;
+        if (status >= 300 && status < 400 && response.headers.location) {
+          response.resume();
+          if (redirectsLeft === 0) {
+            reject(new Error(`Too many redirects while downloading ${url}`));
+            return;
+          }
+          resolve(download(new URL(response.headers.location, url).toString(), redirectsLeft - 1));
+          return;
+        }
+        if (status !== 200) {
+          response.resume();
+          const error = new Error(`Download failed with HTTP ${status}: ${url}`);
+          error.statusCode = status;
+          reject(error);
+          return;
+        }
+
+        const chunks = [];
+        response.on("data", (chunk) => chunks.push(chunk));
+        response.on("end", () => resolve(Buffer.concat(chunks)));
+        response.on("error", reject);
+      }
+    );
+    request.on("error", reject);
+  });
+}
+
+function tarBinary(archive) {
+  const tar = zlib.gunzipSync(archive);
+  let offset = 0;
+  while (offset + 512 <= tar.length) {
+    const header = tar.subarray(offset, offset + 512);
+    if (header.every((byte) => byte === 0)) break;
+    const name = header.subarray(0, 100).toString("utf8").replace(/\0.*$/, "");
+    const sizeText = header.subarray(124, 136).toString("ascii").replace(/\0.*$/, "").trim();
+    const size = Number.parseInt(sizeText || "0", 8);
+    const dataStart = offset + 512;
+    if (!Number.isFinite(size) || dataStart + size > tar.length) {
+      throw new Error("Downloaded tar archive is corrupt");
+    }
+    if (path.posix.basename(name) === "cawide") return tar.subarray(dataStart, dataStart + size);
+    offset = dataStart + Math.ceil(size / 512) * 512;
+  }
+  throw new Error("Downloaded archive does not contain the cawide binary");
+}
+
+function zipBinary(archive) {
+  const endSignature = 0x06054b50;
+  const centralSignature = 0x02014b50;
+  const localSignature = 0x04034b50;
+  const searchStart = Math.max(0, archive.length - 65557);
+  let endOffset = -1;
+  for (let offset = archive.length - 22; offset >= searchStart; offset -= 1) {
+    if (archive.readUInt32LE(offset) === endSignature) {
+      endOffset = offset;
+      break;
+    }
+  }
+  if (endOffset < 0) throw new Error("Downloaded zip archive is corrupt");
+
+  const entryCount = archive.readUInt16LE(endOffset + 10);
+  let offset = archive.readUInt32LE(endOffset + 16);
+  for (let index = 0; index < entryCount; index += 1) {
+    if (archive.readUInt32LE(offset) !== centralSignature) {
+      throw new Error("Downloaded zip archive has an invalid directory");
+    }
+    const method = archive.readUInt16LE(offset + 10);
+    const compressedSize = archive.readUInt32LE(offset + 20);
+    const fileNameLength = archive.readUInt16LE(offset + 28);
+    const extraLength = archive.readUInt16LE(offset + 30);
+    const commentLength = archive.readUInt16LE(offset + 32);
+    const localOffset = archive.readUInt32LE(offset + 42);
+    const name = archive.subarray(offset + 46, offset + 46 + fileNameLength).toString("utf8");
+
+    if (path.posix.basename(name.replace(/\\/g, "/")) === "cawide.exe") {
+      if (archive.readUInt32LE(localOffset) !== localSignature) {
+        throw new Error("Downloaded zip archive has an invalid entry");
+      }
+      const localNameLength = archive.readUInt16LE(localOffset + 26);
+      const localExtraLength = archive.readUInt16LE(localOffset + 28);
+      const dataStart = localOffset + 30 + localNameLength + localExtraLength;
+      const compressed = archive.subarray(dataStart, dataStart + compressedSize);
+      if (method === 0) return compressed;
+      if (method === 8) return zlib.inflateRawSync(compressed);
+      throw new Error(`Downloaded zip uses unsupported compression method ${method}`);
+    }
+    offset += 46 + fileNameLength + extraLength + commentLength;
+  }
+  throw new Error("Downloaded archive does not contain cawide.exe");
+}
+
+async function installBinary(destination) {
+  const extension = process.platform === "win32" ? "zip" : "tar.gz";
+  let lastError;
+  for (const target of platformTargets()) {
+    const asset = `cawide-${target}.${extension}`;
+    const url = `${RELEASE_BASE}/${asset}`;
+    try {
+      process.stderr.write(`Downloading Cawide v${VERSION} for ${target}...\n`);
+      const archive = await download(url);
+      const binary = extension === "zip" ? zipBinary(archive) : tarBinary(archive);
+      fs.mkdirSync(path.dirname(destination), { recursive: true });
+      const temporary = `${destination}.${process.pid}.tmp`;
+      try {
+        fs.writeFileSync(temporary, binary, { mode: 0o755 });
+        fs.chmodSync(temporary, 0o755);
+        fs.renameSync(temporary, destination);
+      } finally {
+        if (fs.existsSync(temporary)) fs.unlinkSync(temporary);
+      }
+      return;
+    } catch (error) {
+      lastError = error;
+      if (error.statusCode !== 404) break;
+    }
+  }
+  throw lastError;
+}
+
+function run(binaryPath) {
+  const result = childProcess.spawnSync(binaryPath, process.argv.slice(2), { stdio: "inherit" });
+  if (result.error) throw result.error;
+  if (result.signal && SIGNAL_EXIT_CODES[result.signal])
+    process.exit(SIGNAL_EXIT_CODES[result.signal]);
+  process.exit(result.status ?? 0);
+}
+
+async function main() {
+  const local = localBinary();
+  if (local) run(local);
+
+  const cached = cacheBinary();
+  if (!fs.existsSync(cached)) await installBinary(cached);
+  run(cached);
+}
+
+main().catch((error) => {
+  process.stderr.write(`cawide: ${error.message}\n`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "cawide",
+  "version": "0.4.4",
+  "description": "Desktop companion daemon for Cawide remote coding terminal",
+  "bin": {
+    "cawide": "./bin/cawide.js"
+  },
+  "files": ["bin/", "README.md"],
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/longd2k3/cawide.git"
+  },
+  "keywords": ["cawide", "terminal", "ai-agent", "remote-editor", "gpui"],
+  "author": "Cawide Team",
+  "license": "MIT"
+}