@glock-org/glock 1.0.0

package/bin/glock.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+
+/**
+ * Glock CLI launcher
+ *
+ * This script launches the platform-appropriate Glock binary.
+ * The binary is downloaded during npm postinstall.
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+
+const platform = os.platform();
+const arch = os.arch();
+
+// Map Node.js arch names to our binary names
+const archMap = {
+  'x64': 'x64',
+  'arm64': 'arm64',
+};
+
+const platformMap = {
+  'darwin': 'darwin',
+  'linux': 'linux',
+  'win32': 'win32',
+};
+
+const mappedPlatform = platformMap[platform];
+const mappedArch = archMap[arch];
+
+if (!mappedPlatform || !mappedArch) {
+  console.error(`Unsupported platform: ${platform}-${arch}`);
+  process.exit(1);
+}
+
+const binaryName = platform === 'win32' ? 'glock.exe' : 'glock';
+const binaryDir = path.join(__dirname, '..', 'bin', `glock-${mappedPlatform}-${mappedArch}`);
+const binaryPath = path.join(binaryDir, binaryName);
+
+// Check if binary exists
+if (!fs.existsSync(binaryPath)) {
+  console.error('Glock binary not found. Please reinstall the package.');
+  console.error(`Expected binary at: ${binaryPath}`);
+  console.error('');
+  console.error('Try running: npm install -g glock/glock');
+  process.exit(1);
+}
+
+// Spawn the binary with all arguments
+const child = spawn(binaryPath, process.argv.slice(2), {
+  stdio: 'inherit',
+  env: {
+    ...process.env,
+    GLOCK_NPM_INSTALL: '1',
+  },
+});
+
+child.on('error', (err) => {
+  console.error(`Failed to start Glock: ${err.message}`);
+  process.exit(1);
+});
+
+child.on('exit', (code, signal) => {
+  if (signal) {
+    process.exit(1);
+  }
+  process.exit(code || 0);
+});
+
+// Handle signals
+process.on('SIGINT', () => {
+  child.kill('SIGINT');
+});
+
+process.on('SIGTERM', () => {
+  child.kill('SIGTERM');
+});

package/lib/platform.js

@@ -0,0 +1,234 @@
+/**
+ * Platform detection for Glock CLI binary downloads.
+ *
+ * Determines the correct binary to download based on:
+ * - Operating system (darwin, linux, win32)
+ * - Architecture (x64, arm64)
+ */
+
+const os = require('os');
+const path = require('path');
+
+/**
+ * Supported platforms and architectures
+ */
+const SUPPORTED_PLATFORMS = {
+  darwin: ['x64', 'arm64'],
+  linux: ['x64', 'arm64'],
+  win32: ['x64'],
+};
+
+/**
+ * Binary file names by platform
+ */
+const BINARY_NAMES = {
+  darwin: 'glock',
+  linux: 'glock',
+  win32: 'glock.exe',
+};
+
+/**
+ * Get the current platform identifier
+ * @returns {string} Platform identifier (e.g., 'darwin-arm64')
+ */
+function getPlatformId() {
+  const platform = os.platform();
+  const arch = os.arch();
+  return `${platform}-${arch}`;
+}
+
+/**
+ * Check if the current platform is supported
+ * @returns {boolean} True if supported
+ */
+function isPlatformSupported() {
+  const platform = os.platform();
+  const arch = os.arch();
+
+  const supportedArchs = SUPPORTED_PLATFORMS[platform];
+  if (!supportedArchs) {
+    return false;
+  }
+
+  return supportedArchs.includes(arch);
+}
+
+/**
+ * Get the binary name for the current platform
+ * @returns {string} Binary file name
+ */
+function getBinaryName() {
+  const platform = os.platform();
+  return BINARY_NAMES[platform] || 'glock';
+}
+
+/**
+ * Get the download URL for the binary
+ * @param {string} version - Version to download (e.g., '1.0.0')
+ * @param {string} baseUrl - Base URL for downloads
+ * @returns {string} Full download URL
+ */
+function getDownloadUrl(version, baseUrl = 'https://github.com/glock/glock/releases/download') {
+  const platform = os.platform();
+  const arch = os.arch();
+  const platformId = `${platform}-${arch}`;
+
+  return `${baseUrl}/v${version}/glock-${platformId}.tar.gz`;
+}
+
+/**
+ * Get the installation directory for the binary
+ * @returns {string} Installation directory path
+ */
+function getInstallDir() {
+  return path.join(__dirname, '..', 'bin', getPlatformId());
+}
+
+/**
+ * Get the full path to the installed binary
+ * @returns {string} Full binary path
+ */
+function getBinaryPath() {
+  return path.join(getInstallDir(), getBinaryName());
+}
+
+/**
+ * Get platform-specific environment variables
+ * @returns {Object} Environment variables to set
+ */
+function getPlatformEnv() {
+  const env = {
+    GLOCK_NPM_INSTALL: '1',
+    GLOCK_PLATFORM: getPlatformId(),
+  };
+
+  // Platform-specific additions
+  const platform = os.platform();
+
+  if (platform === 'darwin') {
+    // macOS-specific
+    env.GLOCK_MACOS_VERSION = os.release();
+  } else if (platform === 'linux') {
+    // Linux-specific
+    env.GLOCK_LINUX_DISTRO = detectLinuxDistro();
+  }
+
+  return env;
+}
+
+/**
+ * Detect Linux distribution (best effort)
+ * @returns {string} Distribution name or 'unknown'
+ */
+function detectLinuxDistro() {
+  try {
+    const fs = require('fs');
+
+    // Try /etc/os-release first
+    if (fs.existsSync('/etc/os-release')) {
+      const content = fs.readFileSync('/etc/os-release', 'utf8');
+      const match = content.match(/^ID=(.*)$/m);
+      if (match) {
+        return match[1].replace(/"/g, '');
+      }
+    }
+
+    // Fallback checks
+    if (fs.existsSync('/etc/debian_version')) {
+      return 'debian';
+    }
+    if (fs.existsSync('/etc/redhat-release')) {
+      return 'redhat';
+    }
+    if (fs.existsSync('/etc/alpine-release')) {
+      return 'alpine';
+    }
+
+    return 'unknown';
+  } catch (e) {
+    return 'unknown';
+  }
+}
+
+/**
+ * Get system information for debugging
+ * @returns {Object} System information
+ */
+function getSystemInfo() {
+  return {
+    platform: os.platform(),
+    arch: os.arch(),
+    release: os.release(),
+    type: os.type(),
+    cpus: os.cpus().length,
+    memory: Math.round(os.totalmem() / (1024 * 1024 * 1024)) + 'GB',
+    node: process.version,
+    npm: process.env.npm_config_user_agent || 'unknown',
+    supported: isPlatformSupported(),
+    platformId: getPlatformId(),
+    binaryName: getBinaryName(),
+    installDir: getInstallDir(),
+    binaryPath: getBinaryPath(),
+  };
+}
+
+/**
+ * Validate that the platform can run Glock
+ * @throws {Error} If platform is not supported
+ */
+function validatePlatform() {
+  if (!isPlatformSupported()) {
+    const platform = os.platform();
+    const arch = os.arch();
+    const supported = Object.entries(SUPPORTED_PLATFORMS)
+      .map(([p, archs]) => `${p} (${archs.join(', ')})`)
+      .join(', ');
+
+    throw new Error(
+      `Glock does not support ${platform}-${arch}.\n` +
+        `Supported platforms: ${supported}\n` +
+        `Please open an issue if you need support for this platform.`
+    );
+  }
+}
+
+/**
+ * Check if running in CI environment
+ * @returns {boolean} True if in CI
+ */
+function isCI() {
+  return !!(
+    process.env.CI ||
+    process.env.CONTINUOUS_INTEGRATION ||
+    process.env.GITHUB_ACTIONS ||
+    process.env.GITLAB_CI ||
+    process.env.CIRCLECI ||
+    process.env.TRAVIS ||
+    process.env.JENKINS_URL
+  );
+}
+
+/**
+ * Get appropriate temp directory for downloads
+ * @returns {string} Temp directory path
+ */
+function getTempDir() {
+  return process.env.GLOCK_TEMP_DIR || os.tmpdir();
+}
+
+module.exports = {
+  getPlatformId,
+  isPlatformSupported,
+  getBinaryName,
+  getDownloadUrl,
+  getInstallDir,
+  getBinaryPath,
+  getPlatformEnv,
+  detectLinuxDistro,
+  getSystemInfo,
+  validatePlatform,
+  isCI,
+  getTempDir,
+  SUPPORTED_PLATFORMS,
+  BINARY_NAMES,
+};

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@glock-org/glock",
+  "version": "1.0.0",
+  "description": "Glock - AI Coding Assistant CLI",
+  "keywords": ["glock", "ai", "coding", "assistant", "cli"],
+  "author": "Glock",
+  "license": "UNLICENSED",
+  "private": false,
+  "homepage": "https://getglock.dev",
+  "bin": {
+    "glock": "./bin/glock.js"
+  },
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "scripts/",
+    "README.md"
+  ],
+  "os": ["darwin", "linux", "win32"],
+  "cpu": ["x64", "arm64"]
+}

package/scripts/postinstall.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+
+/**
+ * Glock postinstall script
+ *
+ * Downloads the appropriate platform binary after npm install.
+ */
+
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+const VERSION = require('../package.json').version;
+const PLATFORM = os.platform();
+const ARCH = os.arch();
+
+// Map to our binary naming convention
+const platformMap = {
+  'darwin': 'darwin',
+  'linux': 'linux',
+  'win32': 'win32',
+};
+
+const archMap = {
+  'x64': 'x64',
+  'arm64': 'arm64',
+};
+
+const mappedPlatform = platformMap[PLATFORM];
+const mappedArch = archMap[ARCH];
+
+if (!mappedPlatform || !mappedArch) {
+  console.error(`Unsupported platform: ${PLATFORM}-${ARCH}`);
+  console.error('Glock supports: darwin-x64, darwin-arm64, linux-x64, linux-arm64, win32-x64');
+  process.exit(1);
+}
+
+const BINARY_NAME = PLATFORM === 'win32' ? 'glock.exe' : 'glock';
+const DOWNLOAD_BASE = 'https://glock-releases.s3.amazonaws.com';
+
+async function downloadBinary() {
+  const url = `${DOWNLOAD_BASE}/v${VERSION}/glock-${mappedPlatform}-${mappedArch}.tar.gz`;
+  console.log(`Download URL: ${url}`);
+  const binDir = path.join(__dirname, '..', 'bin', `glock-${mappedPlatform}-${mappedArch}`);
+  const tarPath = path.join(binDir, 'glock.tar.gz');
+
+  console.log(`Downloading Glock v${VERSION} for ${mappedPlatform}-${mappedArch}...`);
+
+  // Create directory
+  fs.mkdirSync(binDir, { recursive: true });
+
+  // Download file
+  await new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(tarPath);
+
+    const request = (downloadUrl) => {
+      https.get(downloadUrl, (response) => {
+        // Handle redirects
+        if (response.statusCode === 301 || response.statusCode === 302) {
+          const redirectUrl = response.headers.location;
+          if (redirectUrl) {
+            request(redirectUrl);
+            return;
+          }
+        }
+
+        if (response.statusCode !== 200) {
+          reject(new Error(`Download failed: HTTP ${response.statusCode}`));
+          return;
+        }
+
+        response.pipe(file);
+        file.on('finish', () => {
+          file.close();
+          resolve();
+        });
+      }).on('error', (err) => {
+        fs.unlink(tarPath, () => {});
+        reject(err);
+      });
+    };
+
+    request(url);
+  });
+
+  // Extract archive
+  console.log('Extracting...');
+  try {
+    execSync(`tar -xzf glock.tar.gz`, { cwd: binDir, stdio: 'pipe' });
+  } catch (err) {
+    // Try with gzip separately on some systems
+    try {
+      execSync(`gzip -d glock.tar.gz && tar -xf glock.tar`, { cwd: binDir, stdio: 'pipe' });
+    } catch (err2) {
+      throw new Error('Failed to extract archive. Please ensure tar is available.');
+    }
+  }
+
+  // Clean up archive
+  try {
+    fs.unlinkSync(tarPath);
+  } catch (e) {
+    // Ignore cleanup errors
+  }
+  try {
+    fs.unlinkSync(path.join(binDir, 'glock.tar'));
+  } catch (e) {
+    // Ignore cleanup errors
+  }
+
+  // Make executable on Unix
+  if (PLATFORM !== 'win32') {
+    const binaryPath = path.join(binDir, BINARY_NAME);
+    fs.chmodSync(binaryPath, 0o755);
+  }
+
+  console.log('Glock installed successfully!');
+  console.log('');
+  console.log('Run `glock` to start an interactive session.');
+}
+
+// Only run if not in CI or if explicitly requested
+const skipDownload = process.env.GLOCK_SKIP_BINARY_DOWNLOAD === '1';
+const isCI = process.env.CI === 'true';
+
+if (skipDownload) {
+  console.log('Skipping binary download (GLOCK_SKIP_BINARY_DOWNLOAD=1)');
+  process.exit(0);
+}
+
+downloadBinary().catch((err) => {
+  console.error('');
+  console.error('Failed to download Glock binary:', err.message);
+  console.error('');
+  console.error('You can try:');
+  console.error('  1. Check your network connection');
+  console.error('  2. Download manually from https://glock-releases.s3.amazonaws.com');
+  console.error('  3. Contact support at https://getglock.dev');
+  console.error('');
+
+  // Don't fail the install - the binary might be added manually
+  if (!isCI) {
+    process.exit(0);
+  }
+  process.exit(1);
+});