@hasna/codewith 0.1.2

package/README.md

@@ -0,0 +1,52 @@
+<p align="center"><strong>Codewith</strong> is a command-line coding agent from Hasna that runs locally on your computer.</p>
+
+---
+
+## Quickstart
+
+### Installing and running Codewith
+
+Run the following on Mac, Linux, or Windows to install Codewith:
+
+```shell
+bun install -g @hasna/codewith
+```
+
+Codewith can also be installed through npm:
+
+```shell
+npm install -g @hasna/codewith
+```
+
+Then run `codewith` to get started. Codewith stores its local state in `~/.codewith` by default.
+
+<details>
+<summary>You can also download a platform binary from the latest Codewith GitHub Release.</summary>
+
+Each GitHub Release contains many executables, but in practice, you likely want one of these:
+
+- macOS
+  - Apple Silicon/arm64: `codewith-aarch64-apple-darwin.tar.gz`
+  - x86_64 (older Mac hardware): `codewith-x86_64-apple-darwin.tar.gz`
+- Linux
+  - x86_64: `codewith-x86_64-unknown-linux-musl.tar.gz`
+  - arm64: `codewith-aarch64-unknown-linux-musl.tar.gz`
+
+Each archive contains a single entry with the platform baked into the name (e.g., `codewith-x86_64-unknown-linux-musl`), so you likely want to rename it to `codewith` after extracting it.
+
+</details>
+
+### Using Codewith with your ChatGPT plan
+
+Run `codewith` and select **Sign in with ChatGPT**. We recommend signing into your ChatGPT account to use Codewith as part of your Plus, Pro, Business, Edu, or Enterprise plan. [Learn more about what's included in your ChatGPT plan](https://help.openai.com/en/articles/11369540-codex-in-chatgpt).
+
+You can also use Codewith with an API key.
+
+## Docs
+
+- [**Authentication**](./docs/authentication.md)
+- [**Contributing**](./docs/contributing.md)
+- [**Installing & building**](./docs/install.md)
+- [**Open source fund**](./docs/open-source-fund.md)
+
+This repository is licensed under the [Apache-2.0 License](LICENSE).

package/bin/codex.js

@@ -0,0 +1,255 @@
+#!/usr/bin/env node
+// Unified entry point for the Codewith CLI.
+
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, realpathSync, chmodSync } from "fs";
+import { createRequire } from "node:module";
+import { homedir } from "node:os";
+import path from "path";
+import { fileURLToPath } from "url";
+
+// __dirname equivalent in ESM
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const require = createRequire(import.meta.url);
+
+const PLATFORM_PACKAGE_BY_TARGET = {
+  "x86_64-unknown-linux-musl": "@hasna/codewith-linux-x64",
+  "aarch64-unknown-linux-musl": "@hasna/codewith-linux-arm64",
+  "x86_64-apple-darwin": "@hasna/codewith-darwin-x64",
+  "aarch64-apple-darwin": "@hasna/codewith-darwin-arm64",
+  "x86_64-pc-windows-msvc": "@hasna/codewith-win32-x64",
+  "aarch64-pc-windows-msvc": "@hasna/codewith-win32-arm64",
+};
+
+const { platform, arch } = process;
+
+let targetTriple = null;
+switch (platform) {
+  case "linux":
+  case "android":
+    switch (arch) {
+      case "x64":
+        targetTriple = "x86_64-unknown-linux-musl";
+        break;
+      case "arm64":
+        targetTriple = "aarch64-unknown-linux-musl";
+        break;
+      default:
+        break;
+    }
+    break;
+  case "darwin":
+    switch (arch) {
+      case "x64":
+        targetTriple = "x86_64-apple-darwin";
+        break;
+      case "arm64":
+        targetTriple = "aarch64-apple-darwin";
+        break;
+      default:
+        break;
+    }
+    break;
+  case "win32":
+    switch (arch) {
+      case "x64":
+        targetTriple = "x86_64-pc-windows-msvc";
+        break;
+      case "arm64":
+        targetTriple = "aarch64-pc-windows-msvc";
+        break;
+      default:
+        break;
+    }
+    break;
+  default:
+    break;
+}
+
+if (!targetTriple) {
+  throw new Error(`Unsupported platform: ${platform} (${arch})`);
+}
+
+const platformPackage = PLATFORM_PACKAGE_BY_TARGET[targetTriple];
+if (!platformPackage) {
+  throw new Error(`Unsupported target triple: ${targetTriple}`);
+}
+
+const codexBinaryName = process.platform === "win32" ? "codex.exe" : "codex";
+const localVendorRoot = path.join(__dirname, "..", "vendor");
+const packageBinaryPath = (vendorRoot) =>
+  path.join(vendorRoot, targetTriple, "bin", codexBinaryName);
+const legacyBinaryPath = (vendorRoot) =>
+  path.join(vendorRoot, targetTriple, "codex", codexBinaryName);
+
+function resolveNativePackage(vendorRoot) {
+  const packageRoot = path.join(vendorRoot, targetTriple);
+  const binaryPath = packageBinaryPath(vendorRoot);
+  if (existsSync(binaryPath)) {
+    return {
+      binaryPath,
+      pathDir: path.join(packageRoot, "codex-path"),
+    };
+  }
+
+  const legacyPath = legacyBinaryPath(vendorRoot);
+  if (existsSync(legacyPath)) {
+    return {
+      binaryPath: legacyPath,
+      pathDir: path.join(packageRoot, "path"),
+    };
+  }
+
+  return null;
+}
+
+let nativePackage;
+try {
+  const packageJsonPath = require.resolve(`${platformPackage}/package.json`);
+  nativePackage = resolveNativePackage(
+    path.join(path.dirname(packageJsonPath), "vendor"),
+  );
+} catch {
+  nativePackage = resolveNativePackage(localVendorRoot);
+}
+
+if (!nativePackage) {
+  const packageManager = detectPackageManager();
+  const updateCommand =
+    packageManager === "bun"
+      ? "bun install -g @hasna/codewith@latest"
+      : "npm install -g @hasna/codewith@latest";
+  throw new Error(
+    `Missing optional dependency ${platformPackage}. Reinstall Codewith: ${updateCommand}`,
+  );
+}
+
+const { binaryPath, pathDir } = nativePackage;
+
+// Use an asynchronous spawn instead of spawnSync so that Node is able to
+// respond to signals (e.g. Ctrl-C / SIGINT) while the native binary is
+// executing. This allows us to forward those signals to the child process
+// and guarantees that when either the child terminates or the parent
+// receives a fatal signal, both processes exit in a predictable manner.
+
+function getUpdatedPath(newDirs) {
+  const pathSep = process.platform === "win32" ? ";" : ":";
+  const existingPath = process.env.PATH || "";
+  const updatedPath = [
+    ...newDirs,
+    ...existingPath.split(pathSep).filter(Boolean),
+  ].join(pathSep);
+  return updatedPath;
+}
+
+/**
+ * Use heuristics to detect the package manager that was used to install
+ * Codewith in order to give the user a hint about how to update it.
+ */
+function detectPackageManager() {
+  const userAgent = process.env.npm_config_user_agent || "";
+  if (/\bbun\//.test(userAgent)) {
+    return "bun";
+  }
+
+  const execPath = process.env.npm_execpath || "";
+  if (execPath.includes("bun")) {
+    return "bun";
+  }
+
+  if (
+    __dirname.includes(".bun/install/global") ||
+    __dirname.includes(".bun\\install\\global")
+  ) {
+    return "bun";
+  }
+
+  return userAgent ? "npm" : null;
+}
+
+const additionalDirs = [];
+if (existsSync(pathDir)) {
+  additionalDirs.push(pathDir);
+}
+const updatedPath = getUpdatedPath(additionalDirs);
+
+const env = { ...process.env, PATH: updatedPath };
+function defaultCodewithHome() {
+  const home = process.env.HOME || process.env.USERPROFILE || homedir();
+  return path.join(home, ".codewith");
+}
+
+function resolveCodewithHome() {
+  return env.CODEWITH_HOME || defaultCodewithHome();
+}
+
+env.CODEX_HOME = resolveCodewithHome();
+env.CODEWITH_HOME = env.CODEX_HOME;
+mkdirSync(env.CODEX_HOME, { recursive: true, mode: 0o700 });
+if (process.platform !== "win32") {
+  chmodSync(env.CODEX_HOME, 0o700);
+}
+
+const packageManagerEnvVar =
+  detectPackageManager() === "bun"
+    ? "CODEX_MANAGED_BY_BUN"
+    : "CODEX_MANAGED_BY_NPM";
+env[packageManagerEnvVar] = "1";
+env.CODEX_MANAGED_PACKAGE_ROOT = realpathSync(path.join(__dirname, ".."));
+
+const child = spawn(binaryPath, process.argv.slice(2), {
+  stdio: "inherit",
+  env,
+});
+
+child.on("error", (err) => {
+  // Typically triggered when the binary is missing or not executable.
+  // Re-throwing here will terminate the parent with a non-zero exit code
+  // while still printing a helpful stack trace.
+  // eslint-disable-next-line no-console
+  console.error(err);
+  process.exit(1);
+});
+
+// Forward common termination signals to the child so that it shuts down
+// gracefully. In the handler we temporarily disable the default behavior of
+// exiting immediately; once the child has been signaled we simply wait for
+// its exit event which will in turn terminate the parent (see below).
+const forwardSignal = (signal) => {
+  if (child.killed) {
+    return;
+  }
+  try {
+    child.kill(signal);
+  } catch {
+    /* ignore */
+  }
+};
+
+["SIGINT", "SIGTERM", "SIGHUP"].forEach((sig) => {
+  process.on(sig, () => forwardSignal(sig));
+});
+
+// When the child exits, mirror its termination reason in the parent so that
+// shell scripts and other tooling observe the correct exit status.
+// Wrap the lifetime of the child process in a Promise so that we can await
+// its termination in a structured way. The Promise resolves with an object
+// describing how the child exited: either via exit code or due to a signal.
+const childResult = await new Promise((resolve) => {
+  child.on("exit", (code, signal) => {
+    if (signal) {
+      resolve({ type: "signal", signal });
+    } else {
+      resolve({ type: "code", exitCode: code ?? 1 });
+    }
+  });
+});
+
+if (childResult.type === "signal") {
+  // Re-emit the same signal so that the parent terminates with the expected
+  // semantics (this also sets the correct exit code of 128 + n).
+  process.kill(process.pid, childResult.signal);
+} else {
+  process.exit(childResult.exitCode);
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@hasna/codewith",
+  "version": "0.1.2",
+  "description": "Codewith command-line coding agent from Hasna.",
+  "license": "Apache-2.0",
+  "bin": {
+    "codewith": "bin/codex.js"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=16"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "files": [
+    "bin/codex.js"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hasna/codewith.git",
+    "directory": "codex-cli"
+  },
+  "packageManager": "pnpm@10.33.0+sha512.10568bb4a6afb58c9eb3630da90cc9516417abebd3fabbe6739f0ae795728da1491e9db5a544c76ad8eb7570f5c4bb3d6c637b2cb41bfdcdb47fa823c8649319",
+  "optionalDependencies": {
+    "@hasna/codewith-linux-x64": "0.1.2",
+    "@hasna/codewith-linux-arm64": "0.1.2",
+    "@hasna/codewith-darwin-x64": "0.1.2",
+    "@hasna/codewith-darwin-arm64": "0.1.2",
+    "@hasna/codewith-win32-x64": "0.1.2",
+    "@hasna/codewith-win32-arm64": "0.1.2"
+  }
+}