ccfly 0.1.0

package/bin/ccfly.js

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+"use strict";
+
+/**
+ * ccfly CLI launcher.
+ *
+ * Resolves the prebuilt Go binary for the current platform from the matching
+ * optional dependency `ccfly-<os>-<arch>` and execs it, forwarding argv.
+ *
+ * Follows the esbuild/swc model: the main `ccfly` package ships no binary; it
+ * declares one optionalDependency per platform, each carrying a single prebuilt
+ * executable plus its own `os`/`cpu` fields so npm installs exactly the one that
+ * matches the consumer's machine. This shim is the runtime resolver.
+ *
+ *   process.platform -> npm "os"  token: darwin | linux | win32
+ *   process.arch     -> npm "cpu" token: arm64  | x64
+ *
+ * Subpackages are named `ccfly-${platform}-${arch}` to match these tokens 1:1.
+ */
+
+const { spawnSync } = require("node:child_process");
+
+const SUPPORTED = new Set([
+  "darwin-arm64",
+  "darwin-x64",
+  "linux-arm64",
+  "linux-x64",
+]);
+
+/**
+ * On musl-based Linux distros (e.g. Alpine) glibc binaries won't run. We don't
+ * ship a separate musl build yet, but detect it so the error is actionable
+ * instead of a confusing runtime crash. Returns "glibc" | "musl".
+ */
+function detectLibc() {
+  if (process.platform !== "linux") return "glibc";
+  try {
+    const report =
+      typeof process.report?.getReport === "function"
+        ? process.report.getReport()
+        : null;
+    const header = report && report.header;
+    if (header) {
+      if (header.glibcVersionRuntime) return "glibc";
+      // glibcVersionRuntime is absent on musl builds of Node.
+      if ("glibcVersionRuntime" in header) return "musl";
+    }
+  } catch {
+    /* fall through to glibc default */
+  }
+  return "glibc";
+}
+
+function packageName() {
+  return `ccfly-${process.platform}-${process.arch}`;
+}
+
+function resolveBinaryPath() {
+  const target = `${process.platform}-${process.arch}`;
+  const pkg = packageName();
+  const exe = process.platform === "win32" ? "ccfly.exe" : "ccfly";
+
+  if (!SUPPORTED.has(target)) {
+    const hint =
+      target.startsWith("linux") && detectLibc() === "musl"
+        ? " (musl libc detected; only glibc Linux builds are published)"
+        : "";
+    throw new Error(
+      `ccfly: no prebuilt binary for platform "${target}"${hint}.\n` +
+        `Supported platforms: ${[...SUPPORTED].join(", ")}.`
+    );
+  }
+
+  if (process.platform === "linux" && detectLibc() === "musl") {
+    throw new Error(
+      `ccfly: detected musl libc (e.g. Alpine), but only glibc Linux builds ` +
+        `are published. Use a glibc-based image or install glibc compatibility.`
+    );
+  }
+
+  // `${pkg}/bin/${exe}` is the published layout of each platform subpackage.
+  // require.resolve walks node_modules from this file, so it finds the
+  // optionalDependency npm installed for this platform.
+  try {
+    return require.resolve(`${pkg}/bin/${exe}`);
+  } catch (err) {
+    const e = new Error(
+      `ccfly: the platform package "${pkg}" is not installed.\n` +
+        `It should be pulled in automatically as an optional dependency of ` +
+        `"ccfly". This usually means:\n` +
+        `  - the install ran with --no-optional or --omit=optional, or\n` +
+        `  - npm could not download "${pkg}" for ${target}.\n` +
+        `Try reinstalling:  npm i ccfly   (or directly:  npm i ${pkg})`
+    );
+    e.cause = err;
+    throw e;
+  }
+}
+
+function main() {
+  let binPath;
+  try {
+    binPath = resolveBinaryPath();
+  } catch (err) {
+    process.stderr.write((err && err.message ? err.message : String(err)) + "\n");
+    process.exit(1);
+    return;
+  }
+
+  // Default subcommand is `serve` when invoked with no args: `npx ccfly`.
+  const forwarded = process.argv.slice(2);
+  const args = forwarded.length > 0 ? forwarded : ["serve"];
+
+  const result = spawnSync(binPath, args, {
+    stdio: "inherit",
+    windowsHide: true,
+  });
+
+  if (result.error) {
+    if (result.error.code === "ENOENT") {
+      process.stderr.write(
+        `ccfly: binary not found at ${binPath}. Try reinstalling "ccfly".\n`
+      );
+    } else {
+      process.stderr.write(
+        `ccfly: failed to launch binary: ${result.error.message}\n`
+      );
+    }
+    process.exit(1);
+    return;
+  }
+
+  // Re-raise the child's terminating signal so callers observe it; otherwise
+  // exit with the child's status (defaulting to 1 if somehow null).
+  if (result.signal) {
+    process.kill(process.pid, result.signal);
+    return;
+  }
+  process.exit(result.status == null ? 1 : result.status);
+}
+
+main();

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "ccfly",
+  "version": "0.1.0",
+  "description": "Local Go control service for Claude Code sessions (reads ~/.claude jsonl + drives tmux).",
+  "license": "MIT",
+  "type": "commonjs",
+  "bin": {
+    "ccfly": "bin/ccfly.js"
+  },
+  "files": [
+    "bin"
+  ],
+  "keywords": [
+    "claude",
+    "claude-code",
+    "tmux",
+    "terminal",
+    "websocket",
+    "cli",
+    "ccfly"
+  ],
+  "os": [
+    "darwin",
+    "linux"
+  ],
+  "cpu": [
+    "arm64",
+    "x64"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "comment:platform": "The main package intentionally constrains os/cpu only loosely; the bin shim does the real platform check and resolves the matching ccfly-<os>-<arch> optionalDependency at runtime.",
+  "comment:optionalDependencies": "Per-platform prebuilt binary subpackages. Exactly one installs based on the consumer's os/cpu (npm honors each subpackage's own os/cpu fields). Versions are pinned in lockstep with this package and bumped together by CI/changesets. bin/ccfly.js resolves the matching package at runtime.",
+  "optionalDependencies": {
+    "ccfly-darwin-arm64": "0.1.0",
+    "ccfly-darwin-x64": "0.1.0",
+    "ccfly-linux-arm64": "0.1.0",
+    "ccfly-linux-x64": "0.1.0"
+  },
+  "author": "ccfly",
+  "homepage": "https://github.com/jsdvjx/ccfly#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jsdvjx/ccfly.git",
+    "directory": "packages/cli"
+  }
+}