@costrict/cs 0.0.0-refactor-workflow-202603060823

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 opencode
+
+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/bin/cs

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+
+const childProcess = require("child_process")
+const fs = require("fs")
+const path = require("path")
+const os = require("os")
+
+function run(target) {
+  const DEBUG = process.env.DEBUG === "cs"
+  if (DEBUG) {
+    console.error(`[DEBUG] Executing: ${target} ${process.argv.slice(2).join(' ')}`)
+    console.error(`[DEBUG] target exists: ${fs.existsSync(target)}`)
+  }
+  if (!fs.existsSync(target)) {
+    console.error(`[ERROR] Binary not found: ${target}`)
+    process.exit(1)
+  }
+  const result = childProcess.spawnSync(target, process.argv.slice(2), {
+    stdio: "inherit",
+    shell: process.platform === "win32",
+  })
+  if (result.error) {
+    console.error(`[ERROR] Execution failed: ${result.error.message}`)
+    console.error(`[ERROR] Error code: ${result.error.code}`)
+    process.exit(1)
+  }
+  const code = typeof result.status === "number" ? result.status : 0
+  if (DEBUG) console.error(`[DEBUG] Exit code: ${code}`)
+  process.exit(code)
+}
+
+const envPath = process.env.COSTRICT_BIN_PATH
+if (envPath) {
+  run(envPath)
+}
+
+const scriptPath = fs.realpathSync(__filename)
+const scriptDir = path.dirname(scriptPath)
+
+const platformMap = {
+  darwin: "darwin",
+  linux: "linux",
+  win32: "windows",
+}
+const archMap = {
+  x64: "x64",
+  arm64: "arm64",
+  arm: "arm",
+}
+
+let platform = platformMap[os.platform()]
+if (!platform) {
+  platform = os.platform()
+}
+let arch = archMap[os.arch()]
+if (!arch) {
+  arch = os.arch()
+}
+const base = "@costrict/cs-" + platform + "-" + arch + (platform === "windows" || (platform === "linux" && arch === "x64") ? "-baseline" : "")
+const binary = platform === "windows" ? "cs.exe" : "cs"
+
+function findBinary(startDir) {
+  let current = startDir
+  for (;;) {
+    const modules = path.join(current, "node_modules")
+    if (fs.existsSync(modules)) {
+      const entries = fs.readdirSync(modules)
+      for (const entry of entries) {
+        // Handle scoped packages (e.g., @costrict/cs-darwin-arm64)
+        if (entry.startsWith("@")) {
+          const scopeDir = path.join(modules, entry)
+          if (fs.existsSync(scopeDir)) {
+            const scopedPackages = fs.readdirSync(scopeDir)
+            for (const pkg of scopedPackages) {
+              const fullName = entry + "/" + pkg
+              if (!fullName.startsWith(base)) {
+                continue
+              }
+              const candidate = path.join(scopeDir, pkg, "bin", binary)
+              if (fs.existsSync(candidate)) {
+                return candidate
+              }
+            }
+          }
+        } else {
+          // Handle non-scoped packages
+          if (!entry.startsWith(base)) {
+            continue
+          }
+          const candidate = path.join(modules, entry, "bin", binary)
+          if (fs.existsSync(candidate)) {
+            return candidate
+          }
+        }
+      }
+    }
+    const parent = path.dirname(current)
+    if (parent === current) {
+      return
+    }
+    current = parent
+  }
+}
+
+const resolved = findBinary(scriptDir)
+if (!resolved) {
+  console.error(
+    'It seems that your package manager failed to install the right version of the CoStrict CLI for your platform. You can try manually installing the "' +
+      base +
+      '" package',
+  )
+  process.exit(1)
+}
+
+run(resolved)

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@costrict/cs",
+  "bin": {
+    "cs": "./bin/cs"
+  },
+  "scripts": {
+    "postinstall": "bun ./postinstall.mjs || node ./postinstall.mjs"
+  },
+  "version": "0.0.0-refactor-workflow-202603060823",
+  "license": "MIT",
+  "optionalDependencies": {
+    "@costrict/cs-linux-x64": "0.0.0-refactor-workflow-202603060823"
+  }
+}

package/postinstall.mjs

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+
+import fs from "fs"
+import path from "path"
+import os from "os"
+import { fileURLToPath } from "url"
+import { createRequire } from "module"
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const require = createRequire(import.meta.url)
+
+function detectPlatformAndArch() {
+  // Map platform names
+  let platform
+  switch (os.platform()) {
+    case "darwin":
+      platform = "darwin"
+      break
+    case "linux":
+      platform = "linux"
+      break
+    case "win32":
+      platform = "windows"
+      break
+    default:
+      platform = os.platform()
+      break
+  }
+
+  // Map architecture names
+  let arch
+  switch (os.arch()) {
+    case "x64":
+      arch = "x64"
+      break
+    case "arm64":
+      arch = "arm64"
+      break
+    case "arm":
+      arch = "arm"
+      break
+    default:
+      arch = os.arch()
+      break
+  }
+
+  return { platform, arch }
+}
+
+function findBinary() {
+  const { platform, arch } = detectPlatformAndArch()
+  const packageName = `@costrict/cs-${platform}-${arch}`
+  const binaryName = platform === "windows" ? "cs.exe" : "cs"
+
+  try {
+    // Use require.resolve to find the package
+    const packageJsonPath = require.resolve(`${packageName}/package.json`)
+    const packageDir = path.dirname(packageJsonPath)
+    const binaryPath = path.join(packageDir, "bin", binaryName)
+
+    if (!fs.existsSync(binaryPath)) {
+      throw new Error(`Binary not found at ${binaryPath}`)
+    }
+
+    return { binaryPath, binaryName }
+  } catch (error) {
+    throw new Error(`Could not find package ${packageName}: ${error.message}`)
+  }
+}
+
+function prepareBinDirectory(binaryName) {
+  const binDir = path.join(__dirname, "bin")
+  const targetPath = path.join(binDir, binaryName)
+
+  // Ensure bin directory exists
+  if (!fs.existsSync(binDir)) {
+    fs.mkdirSync(binDir, { recursive: true })
+  }
+
+  // Remove existing binary/symlink if it exists
+  if (fs.existsSync(targetPath)) {
+    fs.unlinkSync(targetPath)
+  }
+
+  return { binDir, targetPath }
+}
+
+function symlinkBinary(sourcePath, binaryName) {
+  const { targetPath } = prepareBinDirectory(binaryName)
+
+  fs.symlinkSync(sourcePath, targetPath)
+  console.log(`cs binary symlinked: ${targetPath} -> ${sourcePath}`)
+
+  // Verify the file exists after operation
+  if (!fs.existsSync(targetPath)) {
+    throw new Error(`Failed to symlink binary to ${targetPath}`)
+  }
+}
+
+async function main() {
+  try {
+    console.log(`[DEBUG] Platform: ${os.platform()}, Arch: ${os.arch()}`)
+    
+    if (os.platform() === "win32") {
+      // On Windows, verify the platform-specific package is installed
+      try {
+        const { binaryPath } = findBinary()
+        console.log(`[DEBUG] Windows binary found at: ${binaryPath}`)
+        console.log("Windows: Platform binary verified successfully")
+      } catch (error) {
+        console.error(`[ERROR] Failed to find Windows binary: ${error.message}`)
+        console.error("[ERROR] This usually means @costrict/cs-windows-x64 was not installed")
+        console.error("[ERROR] Try: npm install @costrict/cs-windows-x64 --save-optional")
+        // Don't exit with error for Windows - let the wrapper handle it
+      }
+      return
+    }
+
+    // On non-Windows platforms, just verify the binary package exists
+    // Don't replace the wrapper script - it handles binary execution
+    const { binaryPath } = findBinary()
+    const target = path.join(__dirname, "bin", ".opencode")
+    if (fs.existsSync(target)) fs.unlinkSync(target)
+    try {
+      fs.linkSync(binaryPath, target)
+    } catch {
+      fs.copyFileSync(binaryPath, target)
+    }
+    fs.chmodSync(target, 0o755)
+  } catch (error) {
+    console.error("Failed to setup cs binary:", error.message)
+    process.exit(1)
+  }
+}
+
+try {
+  main()
+} catch (error) {
+  console.error("Postinstall script error:", error.message)
+  process.exit(0)
+}