@textcortex/zenocode 0.1.2

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@textcortex/zenocode",
+  "version": "0.1.2",
+  "description": "Zenocode CLI launcher for TextCortex models and auth flows.",
+  "private": false,
+  "license": "UNLICENSED",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "scripts"
+  ],
+  "bin": {
+    "zenocode": "scripts/run-codecortex.mjs",
+    "codecortex": "scripts/run-codecortex.mjs"
+  },
+  "scripts": {
+    "build-branded-opencode": "node scripts/build-branded-opencode.mjs",
+    "prepare-config": "node scripts/run-codecortex.mjs --prepare-only",
+    "dev": "node scripts/run-codecortex.mjs",
+    "login": "node scripts/run-codecortex.mjs login",
+    "logout": "node scripts/run-codecortex.mjs logout"
+  }
+}

package/scripts/branding-patch.mjs

@@ -0,0 +1,50 @@
+const openCodeVersionFooterSnippetPattern =
+  /insertNode\(([$\w]+), createTextNode\(`Open`\)\);\s*insertNode\(([$\w]+), ([$\w]+)\);\s*insertNode\(\3, createTextNode\(`Code`\)\);\s*insert\(([$\w]+), \(\) => Installation\.VERSION\);/g;
+
+export function padBinaryReplacement(target, replacement) {
+  if (replacement.length > target.length) {
+    return null;
+  }
+  const paddingLength = target.length - replacement.length;
+  if (paddingLength === 0) {
+    return replacement;
+  }
+  return `${replacement}${" ".repeat(paddingLength)}`;
+}
+
+function _buildZenocodeVersionFooterSnippet(
+  openTextRef,
+  codeContainerRef,
+  codeTextRef,
+  versionRef,
+) {
+  return [
+    `insertNode(${openTextRef}, createTextNode(\`Zeno\`));`,
+    `insertNode(${codeContainerRef}, ${codeTextRef});`,
+    `insertNode(${codeTextRef}, createTextNode(\`code\`));`,
+    `insert(${versionRef}, () => "");`,
+  ].join(" ");
+}
+
+export function patchOpenCodeVersionFooterText(text) {
+  openCodeVersionFooterSnippetPattern.lastIndex = 0;
+  let patched = false;
+  const next = text.replace(
+    openCodeVersionFooterSnippetPattern,
+    (match, openTextRef, codeContainerRef, codeTextRef, versionRef) => {
+      const replacement = _buildZenocodeVersionFooterSnippet(
+        openTextRef,
+        codeContainerRef,
+        codeTextRef,
+        versionRef,
+      );
+      const padded = replacement.length <= match.length ? replacement.padEnd(match.length, " ") : null;
+      if (!padded || padded === match) {
+        return match;
+      }
+      patched = true;
+      return padded;
+    },
+  );
+  return { patched, text: next };
+}

package/scripts/branding-patch.test.mjs

@@ -0,0 +1,39 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { padBinaryReplacement, patchOpenCodeVersionFooterText } from "./branding-patch.mjs";
+
+test("padBinaryReplacement keeps binary length stable", () => {
+  const padded = padBinaryReplacement("abcdef", "abc");
+  assert.equal(padded, "abc   ");
+  assert.equal(padded.length, 6);
+});
+
+test("patchOpenCodeVersionFooterText rewrites OpenCode + version footer", () => {
+  const input = [
+    "insertNode(_el$74, createTextNode(`Open`));",
+    "      insertNode(_el$76, _el$77);",
+    "      insertNode(_el$77, createTextNode(`Code`));",
+    "      insert(_el$80, () => Installation.VERSION);",
+  ].join("\n");
+
+  const result = patchOpenCodeVersionFooterText(input);
+  assert.equal(result.patched, true);
+  assert.equal(result.text.length, input.length);
+  assert.match(result.text, /createTextNode\(`Zeno`\)/);
+  assert.match(result.text, /createTextNode\(`code`\)/);
+  assert.match(result.text, /insert\(_el\$80, \(\) => ""\);/);
+  assert.doesNotMatch(result.text, /Installation\.VERSION/);
+});
+
+test("patchOpenCodeVersionFooterText is a no-op when already branded", () => {
+  const branded = [
+    "insertNode(_el$74, createTextNode(`Zeno`));",
+    "insertNode(_el$76, _el$77);",
+    "insertNode(_el$77, createTextNode(`code`));",
+    "insert(_el$80, () => \"\");",
+  ].join(" ");
+
+  const result = patchOpenCodeVersionFooterText(branded);
+  assert.equal(result.patched, false);
+  assert.equal(result.text, branded);
+});

package/scripts/build-branded-opencode.mjs

@@ -0,0 +1,278 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const appRoot = path.resolve(__dirname, "..");
+const defaultOutputDir = path.join(appRoot, ".zenocode", "brand-build");
+
+const forkUrl =
+  process.env.ZENOCODE_OPENCODE_FORK_URL ||
+  process.env.CODECORTEX_OPENCODE_FORK_URL ||
+  "https://github.com/anomalyco/opencode";
+const forkRef = (process.env.ZENOCODE_OPENCODE_REF || process.env.CODECORTEX_OPENCODE_REF || "").trim();
+const outputDir =
+  process.env.ZENOCODE_BRANDED_OUTPUT_DIR ||
+  process.env.CODECORTEX_BRANDED_OUTPUT_DIR ||
+  defaultOutputDir;
+const wrapperPackageName =
+  process.env.ZENOCODE_BRANDED_PACKAGE ||
+  process.env.CODECORTEX_BRANDED_PACKAGE ||
+  "@textcortex/zenocode-ai";
+const wrapperBinName =
+  process.env.ZENOCODE_BRANDED_BIN_NAME ||
+  process.env.CODECORTEX_BRANDED_BIN_NAME ||
+  "zenocode";
+const publishEnabled =
+  (process.env.ZENOCODE_PUBLISH || process.env.CODECORTEX_PUBLISH) === "1";
+const publishTag =
+  process.env.ZENOCODE_PUBLISH_TAG ||
+  process.env.CODECORTEX_PUBLISH_TAG ||
+  "latest";
+const buildArgs = (
+  process.env.ZENOCODE_OPENCODE_BUILD_ARGS ||
+  process.env.CODECORTEX_OPENCODE_BUILD_ARGS ||
+  ""
+)
+  .trim()
+  .split(/\s+/)
+  .filter(Boolean);
+const cliArgs = process.argv.slice(2);
+
+function _command(name) {
+  if (process.platform === "win32" && ["npm", "pnpm", "npx"].includes(name)) {
+    return `${name}.cmd`;
+  }
+  return name;
+}
+
+async function run(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      stdio: "inherit",
+      ...options,
+    });
+
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(new Error(`${command} ${args.join(" ")} failed with exit code ${String(code ?? 1)}`));
+    });
+  });
+}
+
+async function requireCommand(command, args = ["--version"]) {
+  try {
+    await run(command, args, { stdio: "ignore" });
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      throw new Error(`Missing required command: ${command}`);
+    }
+    throw error;
+  }
+}
+
+async function readJson(filePath) {
+  return JSON.parse(await fs.readFile(filePath, "utf-8"));
+}
+
+async function buildWrapperPackage({
+  checkoutDir,
+  distDir,
+  artifactDir,
+  packageName,
+  binName,
+}) {
+  const distEntries = await fs.readdir(distDir, { withFileTypes: true });
+  const binaries = {};
+  const versions = new Set();
+
+  for (const entry of distEntries) {
+    if (!entry.isDirectory()) continue;
+    const packageJsonPath = path.join(distDir, entry.name, "package.json");
+    try {
+      const pkg = await readJson(packageJsonPath);
+      if (typeof pkg?.name === "string" && typeof pkg?.version === "string") {
+        binaries[pkg.name] = pkg.version;
+        versions.add(pkg.version);
+      }
+    } catch {
+      continue;
+    }
+  }
+
+  if (!Object.keys(binaries).length) {
+    throw new Error(`No binary packages found under ${distDir}`);
+  }
+
+  const version = versions.values().next().value;
+  if (!version) {
+    throw new Error("Unable to determine branded package version");
+  }
+
+  const wrapperDir = path.join(artifactDir, "npm-package");
+  await fs.rm(wrapperDir, { recursive: true, force: true });
+  await fs.mkdir(path.join(wrapperDir, "bin"), { recursive: true });
+
+  const opencodePkgPath = path.join(checkoutDir, "packages", "opencode", "package.json");
+  const opencodePkg = await readJson(opencodePkgPath);
+  const license = typeof opencodePkg?.license === "string" ? opencodePkg.license : "MIT";
+
+  const binMap = { opencode: "./bin/opencode" };
+  if (binName && binName !== "opencode") {
+    binMap[binName] = "./bin/opencode";
+  }
+
+  const wrapperPkg = {
+    name: packageName,
+    version,
+    license,
+    type: "commonjs",
+    bin: binMap,
+    scripts: { postinstall: "node ./postinstall.mjs" },
+    optionalDependencies: binaries,
+  };
+
+  await fs.copyFile(
+    path.join(checkoutDir, "packages", "opencode", "bin", "opencode"),
+    path.join(wrapperDir, "bin", "opencode"),
+  );
+  await fs.copyFile(
+    path.join(checkoutDir, "packages", "opencode", "script", "postinstall.mjs"),
+    path.join(wrapperDir, "postinstall.mjs"),
+  );
+  await fs.copyFile(path.join(checkoutDir, "LICENSE"), path.join(wrapperDir, "LICENSE"));
+  await fs.writeFile(path.join(wrapperDir, "package.json"), `${JSON.stringify(wrapperPkg, null, 2)}\n`, "utf-8");
+
+  const packCommand = _command("npm");
+  await run(packCommand, ["pack"], { cwd: wrapperDir });
+
+  const tarballs = (await fs.readdir(wrapperDir)).filter((entry) => entry.endsWith(".tgz")).sort();
+  if (!tarballs.length) {
+    throw new Error(`npm pack did not produce a tarball in ${wrapperDir}`);
+  }
+
+  const latestTarball = path.join(wrapperDir, tarballs[tarballs.length - 1]);
+  if (publishEnabled) {
+    await run(packCommand, ["publish", latestTarball, "--access", "public", "--tag", publishTag], {
+      cwd: wrapperDir,
+    });
+  }
+
+  return latestTarball;
+}
+
+function pickCurrentPlatformBinary(distPackages) {
+  const platformMap = { darwin: "darwin", linux: "linux", win32: "windows" };
+  const archMap = { x64: "x64", arm64: "arm64" };
+  const expectedPlatform = platformMap[process.platform] || process.platform;
+  const expectedArch = archMap[process.arch] || process.arch;
+  const expectedPrefix = `opencode-${expectedPlatform}-${expectedArch}`;
+
+  const exact = distPackages.find((name) => name === expectedPrefix);
+  if (exact) return exact;
+
+  const prefixed = distPackages.find((name) => name.startsWith(expectedPrefix));
+  if (prefixed) return prefixed;
+
+  return distPackages[0] || null;
+}
+
+async function main() {
+  if (cliArgs.includes("-h") || cliArgs.includes("--help")) {
+    console.log("Build a branded Zenocode opencode binary/package from a fork.");
+    console.log("");
+    console.log("Environment variables:");
+    console.log(`  ZENOCODE_OPENCODE_FORK_URL    Fork URL (default: ${forkUrl})`);
+    console.log("  ZENOCODE_OPENCODE_REF         Branch/tag/commit to build");
+    console.log(`  ZENOCODE_BRANDED_OUTPUT_DIR   Output directory (default: ${outputDir})`);
+    console.log(`  ZENOCODE_BRANDED_PACKAGE      Wrapper package name (default: ${wrapperPackageName})`);
+    console.log(`  ZENOCODE_BRANDED_BIN_NAME     Extra bin name in wrapper (default: ${wrapperBinName})`);
+    console.log("  ZENOCODE_OPENCODE_BUILD_ARGS  Additional args for upstream build script");
+    console.log("  ZENOCODE_PUBLISH=1            Publish tarball to npm");
+    console.log(`  ZENOCODE_PUBLISH_TAG          npm tag (default: ${publishTag})`);
+    console.log("  Legacy CODECORTEX_* env names are still accepted for compatibility.");
+    return;
+  }
+
+  const gitCommand = _command("git");
+  const bunCommand = _command("bun");
+  const npmCommand = _command("npm");
+  await requireCommand(gitCommand);
+  await requireCommand(bunCommand);
+  await requireCommand(npmCommand);
+
+  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "zenocode-opencode-"));
+  const checkoutDir = path.join(tempRoot, "opencode");
+  const distDir = path.join(checkoutDir, "packages", "opencode", "dist");
+  const artifactDir = path.resolve(outputDir);
+
+  try {
+    const cloneArgs = ["clone", "--depth=1"];
+    if (forkRef) {
+      cloneArgs.push("--branch", forkRef);
+    }
+    cloneArgs.push(forkUrl, checkoutDir);
+    await run(gitCommand, cloneArgs);
+
+    await run(bunCommand, ["install"], { cwd: checkoutDir });
+    await run(
+      bunCommand,
+      ["./packages/opencode/script/build.ts", "--single", ...buildArgs],
+      { cwd: checkoutDir },
+    );
+
+    await fs.mkdir(artifactDir, { recursive: true });
+    const npmTarball = await buildWrapperPackage({
+      checkoutDir,
+      distDir,
+      artifactDir,
+      packageName: wrapperPackageName,
+      binName: wrapperBinName,
+    });
+
+    const distEntries = await fs.readdir(distDir, { withFileTypes: true });
+    const distPackages = distEntries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+    const selectedPackage = pickCurrentPlatformBinary(distPackages);
+    if (!selectedPackage) {
+      throw new Error(`No build artifacts found under ${distDir}`);
+    }
+
+    const builtBinaryName = process.platform === "win32" ? "opencode.exe" : "opencode";
+    const builtBinaryPath = path.join(distDir, selectedPackage, "bin", builtBinaryName);
+    const localBinaryDir = path.join(artifactDir, "bin");
+    const localBinaryName = process.platform === "win32" ? "zenocode-opencode.exe" : "zenocode-opencode";
+    const localBinaryPath = path.join(localBinaryDir, localBinaryName);
+
+    await fs.mkdir(localBinaryDir, { recursive: true });
+    await fs.copyFile(builtBinaryPath, localBinaryPath);
+    if (process.platform !== "win32") {
+      await fs.chmod(localBinaryPath, 0o755);
+    }
+
+    console.log("\nZenocode branded build complete.");
+    console.log(`Branded binary: ${localBinaryPath}`);
+    console.log(`Branded package tarball: ${npmTarball}`);
+    if (publishEnabled) {
+      console.log(`Published to npm as ${wrapperPackageName} (tag: ${publishTag}).`);
+    }
+    console.log(`\nRun with local binary:`);
+    console.log(`  export ZENOCODE_OPENCODE_BIN_PATH="${localBinaryPath}"`);
+    console.log(`\nRun with branded package:`);
+    console.log(`  export ZENOCODE_OPENCODE_PACKAGE="${wrapperPackageName}"`);
+  } finally {
+    await fs.rm(tempRoot, { recursive: true, force: true });
+  }
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});