@globant/coda 1.0.0

package/README.md

@@ -0,0 +1,105 @@
+<div align="center">
+
+# CODA
+
+CODA is Globant's AI coding agent, powered by the Glob.AI OS platform. You
+describe what you want to accomplish in plain language — CODA reads your
+codebase, figures out what needs to change, and gets it done, while you stay in
+control of every step.
+
+Developed by [Globant](https://www.globant.com)
+
+</div>
+
+---
+
+## Get Started
+
+Learn more about [glob.ai](https://glob.ai/) and access CODA's latest
+[documentation](https://docs.globant.ai/g-coda).
+
+### macOS & Linux
+
+```bash
+curl -fsSL https://docs.globant.ai/en/filedownload?4622,12 | bash
+```
+
+### Windows (PowerShell 7)
+
+```powershell
+irm 'https://docs.globant.ai/en/filedownload?5346,6' | iex
+```
+
+Alternatively, you can install via npm. Note this requires Node.js, whereas the
+install script above does not:
+
+```bash
+npm i -g @globant/coda
+```
+
+To access the application, type `coda` in your terminal and the TUI should open.
+You may also run CODA in headless mode — read `coda --help` for more
+information.
+
+### Supported platforms
+
+| OS | Architectures |
+|----|---------------|
+| macOS | `arm64`, `x64` |
+| Linux | `x64`, `arm64` (glibc and musl) |
+| Windows | `x64` |
+
+macOS binaries are signed + notarized; Windows binaries are Authenticode-signed.
+
+## Why CODA
+
+### Rebuilt TUI for your workflows
+A rich, terminal-native experience with an **agentic edit loop**, built-in
+tools, and approvals & safety baked in — so the agent acts, but you stay in
+control.
+
+### Powered by Glob.AI OS
+Access major frontier model provider and local models in one application.
+Have access to your favorite models from alternative providers.
+
+- Anthropic
+- OpenAI
+- Vertex-AI
+- AWS Bedrock
+- OpenAI Compatible Models
+- Local Models via Ollama
+
+### Batteries included
+A whole team's worth of superpowers:
+
+- **Parallel & background subagents** — delegate exploration and validation,
+  like a team lead.
+- **Checkpoints, time-travel & memory** — every prompt auto-snapshots the
+  worktree, so you can rewind anytime.
+
+### Extensible by design
+Make it yours. Create your own **tools, commands, and hooks**, and plug into the
+wider ecosystem:
+
+- **Skills & Plugins** — load project-aware playbooks on demand.
+- **MCP servers** — connect external tools and data sources.
+- **Hooks & Extensions** — customize behavior at every lifecycle step.
+- **Workflows** — orchestrate fleets of subagents through deterministic,
+  multi-step pipelines that run themselves.
+
+## Terms & licensing
+
+Use of CODA is governed by Globant's terms of use. By installing or using this
+package you agree to those terms:
+
+**https://www.globant.com/globai-os/terms-of-use**
+
+---
+
+<div align="center">
+
+Your codebase, your terminal, **your AI pair.**
+
+Frontier coding agent · by **Globant**
+
+</div>

package/bin/coda.exe

@@ -0,0 +1,4 @@
+echo "Error: coda native binary not installed." >&2
+echo "postinstall may have been skipped (--ignore-scripts / --omit=optional)." >&2
+echo "Run: node node_modules/@globant/coda/install.cjs   (or reinstall)" >&2
+exit 1

package/cli-wrapper.cjs

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+// Fallback launcher for @globant/coda. Used ONLY when the postinstall
+// (install.cjs) did not run — e.g. `npm install --ignore-scripts`. Resolves the
+// matching native binary from the installed optional platform package and
+// spawns it, inheriting stdio and propagating exit status / signals.
+//
+// NOTE: the PLATFORMS map + detection here intentionally duplicate install.cjs
+// (and a simpler subset of packages/cli/src/update/platform-detect.ts). The npm
+// path never selects baseline variants — npm ships the AVX2 default.
+const { spawnSync } = require("node:child_process");
+const { existsSync } = require("node:fs");
+const { arch } = require("node:os");
+const path = require("node:path");
+
+const PACKAGE_PREFIX = "@globant/coda";
+const WRAPPER_NAME = require("./package.json").name;
+
+const PLATFORMS = {
+  "darwin-arm64": { pkg: `${PACKAGE_PREFIX}-darwin-arm64`, bin: "coda" },
+  "darwin-x64": { pkg: `${PACKAGE_PREFIX}-darwin-x64`, bin: "coda" },
+  "linux-arm64": { pkg: `${PACKAGE_PREFIX}-linux-arm64`, bin: "coda" },
+  "linux-x64": { pkg: `${PACKAGE_PREFIX}-linux-x64`, bin: "coda" },
+  "linux-arm64-musl": {
+    pkg: `${PACKAGE_PREFIX}-linux-arm64-musl`,
+    bin: "coda",
+  },
+  "linux-x64-musl": { pkg: `${PACKAGE_PREFIX}-linux-x64-musl`, bin: "coda" },
+  "windows-arm64": { pkg: `${PACKAGE_PREFIX}-windows-arm64`, bin: "coda.exe" },
+  "windows-x64": { pkg: `${PACKAGE_PREFIX}-windows-x64`, bin: "coda.exe" },
+};
+
+function detectMusl() {
+  if (process.platform !== "linux") return false;
+  const report =
+    typeof process.report?.getReport === "function"
+      ? process.report.getReport()
+      : null;
+  return report != null && report.header?.glibcVersionRuntime === undefined;
+}
+
+function platformKey() {
+  let cpu = arch();
+  if (process.platform === "win32") return `windows-${cpu}`;
+  if (process.platform === "linux") {
+    return `linux-${cpu}${detectMusl() ? "-musl" : ""}`;
+  }
+  if (process.platform === "darwin") {
+    if (cpu === "x64") {
+      const result = spawnSync("sysctl", ["-n", "sysctl.proc_translated"], {
+        encoding: "utf8",
+      });
+      if (result.stdout?.trim() === "1") cpu = "arm64";
+    }
+    return `darwin-${cpu}`;
+  }
+  return `${process.platform}-${cpu}`;
+}
+
+function resolvePlatform() {
+  const info = PLATFORMS[platformKey()];
+  if (!info) {
+    throw new Error(`Unsupported platform: ${platformKey()}`);
+  }
+  const pkgDir = path.dirname(require.resolve(`${info.pkg}/package.json`));
+  return {
+    binary: path.join(pkgDir, info.bin),
+    libDir: path.join(pkgDir, "lib"),
+    assetsDir: path.join(pkgDir, "assets"),
+  };
+}
+
+function main() {
+  let resolved;
+  try {
+    resolved = resolvePlatform();
+  } catch (err) {
+    console.error(
+      `[${WRAPPER_NAME}] Could not locate native binary: ${err.message}`,
+    );
+    process.exit(1);
+  }
+  // The binary runs from the platform package root (lib/ and assets/ are
+  // siblings, not ../lib and ../assets), so point the sidecar + asset resolvers
+  // at the right dirs for this layout.
+  const env = { ...process.env };
+  if (existsSync(resolved.libDir)) {
+    env.CODA_SIDECAR_LIB_DIR = resolved.libDir;
+  }
+  if (existsSync(resolved.assetsDir)) {
+    env.CODA_ASSETS_DIR = resolved.assetsDir;
+  }
+  const result = spawnSync(resolved.binary, process.argv.slice(2), {
+    stdio: "inherit",
+    env,
+  });
+  if (result.error) {
+    console.error(
+      `[${WRAPPER_NAME}] Failed to launch: ${result.error.message}`,
+    );
+    process.exit(1);
+  }
+  if (typeof result.status === "number") {
+    process.exit(result.status);
+  }
+  if (result.signal) {
+    // Mimic the shell convention: 128 + signal number.
+    const signals = { SIGINT: 2, SIGTERM: 15, SIGKILL: 9, SIGHUP: 1 };
+    process.exit(128 + (signals[result.signal] ?? 0));
+  }
+  process.exit(0);
+}
+
+main();

package/install.cjs

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+// Postinstall for @globant/coda. Detects the platform, finds the matching
+// native package from optionalDependencies, and hardlinks (copy fallback) its
+// binary over bin/coda.exe so `coda` execs natively with no resident Node
+// process. Mirrors @anthropic-ai/claude-code's install.cjs, adapted to our
+// `windows` package naming and 8-package optional set.
+//
+// NOTE: this platform detection is a deliberate (simpler) duplicate of the
+// TypeScript logic in packages/cli/src/update/platform-detect.ts. The npm path
+// never selects baseline (non-AVX2) variants — npm ships the AVX2 default — so
+// this file only needs glibc/musl + arch + Rosetta handling.
+const { spawnSync } = require("node:child_process");
+const {
+  linkSync,
+  copyFileSync,
+  unlinkSync,
+  chmodSync,
+  cpSync,
+  existsSync,
+  rmSync,
+} = require("node:fs");
+const { arch } = require("node:os");
+const path = require("node:path");
+
+const PACKAGE_PREFIX = "@globant/coda";
+// Resolved at install time from the published launcher package. Falls back to
+// the package name when `./package.json` is absent (e.g. unit tests that import
+// this file only for its helpers, before the launcher is staged).
+let WRAPPER_NAME = PACKAGE_PREFIX;
+try {
+  WRAPPER_NAME = require("./package.json").name;
+} catch {
+  /* keep fallback */
+}
+
+// key → { pkg, bin }. Keys use OUR `windows` naming; resolution uses
+// process.platform (`win32`) mapped to `windows`.
+const PLATFORMS = {
+  "darwin-arm64": { pkg: `${PACKAGE_PREFIX}-darwin-arm64`, bin: "coda" },
+  "darwin-x64": { pkg: `${PACKAGE_PREFIX}-darwin-x64`, bin: "coda" },
+  "linux-arm64": { pkg: `${PACKAGE_PREFIX}-linux-arm64`, bin: "coda" },
+  "linux-x64": { pkg: `${PACKAGE_PREFIX}-linux-x64`, bin: "coda" },
+  "linux-arm64-musl": {
+    pkg: `${PACKAGE_PREFIX}-linux-arm64-musl`,
+    bin: "coda",
+  },
+  "linux-x64-musl": { pkg: `${PACKAGE_PREFIX}-linux-x64-musl`, bin: "coda" },
+  "windows-arm64": { pkg: `${PACKAGE_PREFIX}-windows-arm64`, bin: "coda.exe" },
+  "windows-x64": { pkg: `${PACKAGE_PREFIX}-windows-x64`, bin: "coda.exe" },
+};
+
+function detectMusl() {
+  if (process.platform !== "linux") return false;
+  const report =
+    typeof process.report?.getReport === "function"
+      ? process.report.getReport()
+      : null;
+  return report != null && report.header?.glibcVersionRuntime === undefined;
+}
+
+function platformKey() {
+  let cpu = arch();
+  if (process.platform === "win32") return `windows-${cpu}`;
+  if (process.platform === "linux") {
+    return `linux-${cpu}${detectMusl() ? "-musl" : ""}`;
+  }
+  if (process.platform === "darwin") {
+    if (cpu === "x64") {
+      const result = spawnSync("sysctl", ["-n", "sysctl.proc_translated"], {
+        encoding: "utf8",
+      });
+      // Rosetta → prefer the arm64 build (the darwin-x64 build needs AVX,
+      // which Rosetta does not emulate).
+      if (result.stdout?.trim() === "1") cpu = "arm64";
+    }
+    return `darwin-${cpu}`;
+  }
+  return `${process.platform}-${cpu}`;
+}
+
+function placeBinary(src, dest) {
+  try {
+    linkSync(src, dest);
+  } catch (err) {
+    if (err.code === "EEXIST") {
+      unlinkSync(dest);
+      try {
+        linkSync(src, dest);
+      } catch {
+        copyFileSync(src, dest);
+      }
+    } else if (err.code === "EXDEV" || err.code === "EPERM") {
+      copyFileSync(src, dest);
+    } else {
+      throw err;
+    }
+  }
+  if (process.platform !== "win32") chmodSync(dest, 0o755);
+}
+
+// Copies the platform package's `lib/` sidecar tree (keytar, opentui, ripgrep)
+// into the launcher root so the compiled binary finds it at `../lib/<name>`,
+// matching the script-installer layout. Idempotent and non-fatal: a failure
+// degrades sidecars exactly as before (binary still runs). `libParent` defaults
+// to the launcher dir; tests pass a temp dir.
+function stageSidecars(platformPkgDir, libParent = __dirname) {
+  const libSrc = path.join(platformPkgDir, "lib");
+  if (!existsSync(libSrc)) return; // older platform pkg without sidecars
+  const libDest = path.join(libParent, "lib");
+  // Remove any stale tree from a previous install so re-runs are clean.
+  if (existsSync(libDest)) {
+    rmSync(libDest, { recursive: true, force: true });
+  }
+  cpSync(libSrc, libDest, { recursive: true });
+  // CI artifact round-trips / cpSync edge cases can drop the exec bit; the
+  // bundled ripgrep binary must stay executable on POSIX (keytar.node and
+  // libopentui.* are dlopen'd, not exec'd, so they need read perms only).
+  if (process.platform !== "win32") {
+    const rg = path.join(libDest, "ripgrep", "rg");
+    if (existsSync(rg)) chmodSync(rg, 0o755);
+  }
+}
+
+// Copies the platform package's `assets/` tree (docs, agents, skills) into the
+// launcher root so the compiled binary finds it at `../assets` (the
+// `bin/coda → ../assets` probe in core's resolveAssetsDir), matching the
+// script-installer layout. Idempotent and non-fatal: a failure degrades to no
+// synced docs/agents/skills (binary still runs). `assetsParent` defaults to the
+// launcher dir; tests pass a temp dir.
+function stageAssets(platformPkgDir, assetsParent = __dirname) {
+  const assetsSrc = path.join(platformPkgDir, "assets");
+  if (!existsSync(assetsSrc)) return; // older platform pkg without assets
+  const assetsDest = path.join(assetsParent, "assets");
+  // Remove any stale tree from a previous install so re-runs are clean.
+  if (existsSync(assetsDest)) {
+    rmSync(assetsDest, { recursive: true, force: true });
+  }
+  cpSync(assetsSrc, assetsDest, { recursive: true });
+}
+
+function main() {
+  const key = platformKey();
+  const info = PLATFORMS[key];
+  const optional = require("./package.json").optionalDependencies || {};
+  if (!info || !optional[info.pkg]) {
+    console.error(
+      `[${WRAPPER_NAME}] No native binary for ${key} on this channel. ` +
+        `Available: ${Object.keys(optional)
+          .map((p) => p.replace(`${PACKAGE_PREFIX}-`, ""))
+          .join(", ")}`,
+    );
+    return; // leave stub; `coda` will print guidance
+  }
+  let platformPkgDir;
+  try {
+    platformPkgDir = path.dirname(require.resolve(`${info.pkg}/package.json`));
+  } catch {
+    console.error(
+      `[${WRAPPER_NAME}] Native package "${info.pkg}" not installed ` +
+        `(--omit=optional or download failed). Fallback: node ${path.join(
+          __dirname,
+          "cli-wrapper.cjs",
+        )}`,
+    );
+    return;
+  }
+
+  const src = path.join(platformPkgDir, info.bin);
+  try {
+    placeBinary(src, path.join(__dirname, "bin", "coda.exe"));
+  } catch (err) {
+    console.error(`[${WRAPPER_NAME}] Failed to place binary: ${err.message}`);
+    process.exitCode = 1;
+    return; // no point staging sidecars if the binary failed
+  }
+
+  // Stage keytar/opentui/ripgrep so auth + bundled tools work on npm installs.
+  try {
+    stageSidecars(platformPkgDir);
+  } catch (err) {
+    // Non-fatal: binary runs; sidecars degrade (auth → file storage,
+    // ripgrep → PATH rg, opentui → default rendering). Surface it so the
+    // keyring regression is not silent.
+    console.error(
+      `[${WRAPPER_NAME}] Failed to stage native sidecars ` +
+        `(OS keyring / bundled ripgrep may be unavailable): ${err.message}`,
+    );
+  }
+
+  // Stage docs/agents/skills so syncBuiltinAssets() populates ~/.coda on npm.
+  try {
+    stageAssets(platformPkgDir);
+  } catch (err) {
+    // Non-fatal: binary runs; the built-in docs/agents/skills simply are not
+    // synced to ~/.coda. Surface it so the regression is not silent.
+    console.error(
+      `[${WRAPPER_NAME}] Failed to stage builtin assets ` +
+        `(docs/agents/skills may be unavailable): ${err.message}`,
+    );
+  }
+}
+
+// Run only when executed directly (npm postinstall), not when required by tests.
+if (require.main === module) {
+  main();
+}
+
+module.exports = { stageSidecars, stageAssets, platformKey, placeBinary };

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@globant/coda",
+  "version": "1.0.0",
+  "description": "Coda CLI — agentic coding assistant (native binary launcher)",
+  "bin": {
+    "coda": "bin/coda.exe"
+  },
+  "scripts": {
+    "postinstall": "node install.cjs"
+  },
+  "optionalDependencies": {
+    "@globant/coda-darwin-arm64": "1.0.0",
+    "@globant/coda-linux-arm64": "1.0.0",
+    "@globant/coda-linux-arm64-musl": "1.0.0",
+    "@globant/coda-linux-x64-musl": "1.0.0",
+    "@globant/coda-linux-x64": "1.0.0",
+    "@globant/coda-darwin-x64": "1.0.0",
+    "@globant/coda-windows-arm64": "1.0.0",
+    "@globant/coda-windows-x64": "1.0.0"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "assets",
+    "install.cjs",
+    "cli-wrapper.cjs",
+    "README.md"
+  ],
+  "license": "SEE LICENSE IN README.md",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/5G-AGE009-HZ/g-coda.git",
+    "directory": "packages/cli"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  }
+}