@textcortex/zenocode 0.1.10 → 0.1.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@textcortex/zenocode",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "description": "Secure, EU-hosted coding agent for TextCortex customers that runs in your terminal, edits files, runs scripts, and more.",
   "keywords": [
     "ai",
@@ -30,6 +30,7 @@
   "scripts": {
     "build-branded-opencode": "node scripts/build-branded-opencode.mjs",
     "prepare-config": "node scripts/run-zenocode.mjs --prepare-only",
+    "prepare-release-version": "node scripts/prepare-release-version.mjs",
     "dev": "node scripts/run-zenocode.mjs",
     "login": "node scripts/run-zenocode.mjs login",
     "logout": "node scripts/run-zenocode.mjs logout"

package/scripts/prepare-release-version.mjs

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+import fs from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const defaultPackageJsonPath = path.resolve(__dirname, "..", "package.json");
+
+export function parseSemver(value) {
+  const match = value.match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+.*)?$/);
+  if (!match) {
+    throw new Error(`Invalid semver: ${value}`);
+  }
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease: match[4] ?? null,
+  };
+}
+
+export function compareSemver(left, right) {
+  const lhs = parseSemver(left);
+  const rhs = parseSemver(right);
+
+  for (const key of ["major", "minor", "patch"]) {
+    if (lhs[key] > rhs[key]) return 1;
+    if (lhs[key] < rhs[key]) return -1;
+  }
+
+  if (lhs.prerelease === rhs.prerelease) return 0;
+  if (lhs.prerelease === null) return 1;
+  if (rhs.prerelease === null) return -1;
+
+  const leftParts = lhs.prerelease.split(".");
+  const rightParts = rhs.prerelease.split(".");
+  const length = Math.max(leftParts.length, rightParts.length);
+  for (let index = 0; index < length; index += 1) {
+    const leftPart = leftParts[index];
+    const rightPart = rightParts[index];
+    if (leftPart === undefined) return -1;
+    if (rightPart === undefined) return 1;
+    const leftNumeric = /^\d+$/.test(leftPart);
+    const rightNumeric = /^\d+$/.test(rightPart);
+    if (leftNumeric && rightNumeric) {
+      const leftValue = Number(leftPart);
+      const rightValue = Number(rightPart);
+      if (leftValue > rightValue) return 1;
+      if (leftValue < rightValue) return -1;
+      continue;
+    }
+    if (leftNumeric && !rightNumeric) return -1;
+    if (!leftNumeric && rightNumeric) return 1;
+    if (leftPart > rightPart) return 1;
+    if (leftPart < rightPart) return -1;
+  }
+
+  return 0;
+}
+
+export function incrementPatchVersion(version) {
+  const parsed = parseSemver(version);
+  return `${parsed.major}.${parsed.minor}.${parsed.patch + 1}`;
+}
+
+export function resolveReleaseVersion(localVersion, publishedVersion) {
+  if (!publishedVersion) {
+    return localVersion;
+  }
+
+  const comparison = compareSemver(localVersion, publishedVersion);
+  if (comparison > 0) {
+    return localVersion;
+  }
+
+  return incrementPatchVersion(publishedVersion);
+}
+
+export async function prepareReleasePackageVersion({
+  packageJsonPath = defaultPackageJsonPath,
+  publishedVersion = null,
+} = {}) {
+  const packageJson = JSON.parse(await fs.readFile(packageJsonPath, "utf-8"));
+  const packageName = String(packageJson.name || "").trim();
+  const localVersion = String(packageJson.version || "").trim();
+
+  if (!packageName) {
+    throw new Error(`Missing package name in ${packageJsonPath}`);
+  }
+  if (!localVersion) {
+    throw new Error(`Missing package version in ${packageJsonPath}`);
+  }
+
+  parseSemver(localVersion);
+  if (publishedVersion) {
+    parseSemver(publishedVersion);
+  }
+
+  const nextVersion = resolveReleaseVersion(localVersion, publishedVersion);
+  const updated = nextVersion !== localVersion;
+
+  if (updated) {
+    packageJson.version = nextVersion;
+    await fs.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`, "utf-8");
+  }
+
+  return {
+    packageName,
+    localVersion,
+    nextVersion,
+    publishedVersion,
+    updated,
+  };
+}
+
+export function parseArgs(argv) {
+  const options = {
+    packageJsonPath: defaultPackageJsonPath,
+    publishedVersion: null,
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--package-json") {
+      if (!argv[index + 1]) {
+        throw new Error("--package-json requires a value");
+      }
+      options.packageJsonPath = path.resolve(argv[index + 1]);
+      index += 1;
+      continue;
+    }
+    if (arg === "--published-version") {
+      options.publishedVersion = (argv[index + 1] || "").trim() || null;
+      index += 1;
+      continue;
+    }
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+
+  return options;
+}
+
+async function main() {
+  const result = await prepareReleasePackageVersion(parseArgs(process.argv.slice(2)));
+  console.log(
+    JSON.stringify(
+      {
+        package_name: result.packageName,
+        local_version: result.localVersion,
+        next_version: result.nextVersion,
+        published_version: result.publishedVersion,
+        updated: result.updated,
+      },
+      null,
+      2,
+    ),
+  );
+}
+
+const invokedPath = process.argv[1] ? path.resolve(process.argv[1]) : "";
+if (invokedPath === fileURLToPath(import.meta.url)) {
+  await main();
+}

package/scripts/prepare-release-version.test.mjs

@@ -0,0 +1,96 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import {
+  parseArgs,
+  prepareReleasePackageVersion,
+  resolveReleaseVersion,
+} from "./prepare-release-version.mjs";
+
+test("resolveReleaseVersion keeps the local version when nothing is published yet", () => {
+  assert.equal(resolveReleaseVersion("0.1.10", null), "0.1.10");
+});
+
+test("resolveReleaseVersion bumps the patch version when the local version matches the published version", () => {
+  assert.equal(resolveReleaseVersion("0.1.10", "0.1.10"), "0.1.11");
+});
+
+test("resolveReleaseVersion bumps from the published version when the local version is behind", () => {
+  assert.equal(resolveReleaseVersion("0.1.9", "0.1.10"), "0.1.11");
+});
+
+test("resolveReleaseVersion keeps an already-ahead local version", () => {
+  assert.equal(resolveReleaseVersion("0.1.11", "0.1.10"), "0.1.11");
+});
+
+test("resolveReleaseVersion rejects invalid semver values", () => {
+  assert.throws(() => resolveReleaseVersion("invalid", "0.1.10"), /Invalid semver/);
+});
+
+test("prepareReleasePackageVersion rewrites package.json when an automatic bump is required", async () => {
+  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "zenocode-version-"));
+  const packageJsonPath = path.join(tempDir, "package.json");
+  await fs.writeFile(
+    packageJsonPath,
+    `${JSON.stringify(
+      {
+        name: "@textcortex/zenocode",
+        version: "0.1.10",
+      },
+      null,
+      2,
+    )}\n`,
+    "utf-8",
+  );
+
+  const result = await prepareReleasePackageVersion({
+    packageJsonPath,
+    publishedVersion: "0.1.10",
+  });
+
+  const packageJson = JSON.parse(await fs.readFile(packageJsonPath, "utf-8"));
+  assert.deepEqual(result, {
+    packageName: "@textcortex/zenocode",
+    localVersion: "0.1.10",
+    nextVersion: "0.1.11",
+    publishedVersion: "0.1.10",
+    updated: true,
+  });
+  assert.equal(packageJson.version, "0.1.11");
+});
+
+test("prepareReleasePackageVersion leaves package.json untouched when the local version is already ahead", async () => {
+  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "zenocode-version-"));
+  const packageJsonPath = path.join(tempDir, "package.json");
+  const originalContents = `${JSON.stringify(
+    {
+      name: "@textcortex/zenocode",
+      version: "0.1.11",
+    },
+    null,
+    2,
+  )}\n`;
+  await fs.writeFile(packageJsonPath, originalContents, "utf-8");
+
+  const result = await prepareReleasePackageVersion({
+    packageJsonPath,
+    publishedVersion: "0.1.10",
+  });
+
+  const packageJson = await fs.readFile(packageJsonPath, "utf-8");
+  assert.deepEqual(result, {
+    packageName: "@textcortex/zenocode",
+    localVersion: "0.1.11",
+    nextVersion: "0.1.11",
+    publishedVersion: "0.1.10",
+    updated: false,
+  });
+  assert.equal(packageJson, originalContents);
+});
+
+test("parseArgs requires a value after --package-json", () => {
+  assert.throws(() => parseArgs(["--package-json"]), /--package-json requires a value/);
+});

package/scripts/run-zenocode.mjs

@@ -576,6 +576,16 @@ export function resolveTextCortexBaseUrl({
   return envBaseUrl || storedBaseUrl || cloudBaseUrlDefault;
 }
 
+export function resolveLoginBaseUrl({
+  envBaseUrl,
+  preferLocalhost = false,
+} = {}) {
+  if (preferLocalhost) {
+    return localBaseUrlDefault;
+  }
+  return envBaseUrl || cloudBaseUrlDefault;
+}
+
 function _loginConnectivityHelp(baseUrl) {
   return [
     `Cannot reach Zenocode auth endpoint at ${baseUrl}.`,
@@ -1578,7 +1588,14 @@ async function main() {
   const subcommand = runtimeArgs[0];
 
   if (subcommand === "login") {
-    await runLoginCommand(baseUrl, runtimeArgs.slice(1), { preferLocalhost });
+    await runLoginCommand(
+      resolveLoginBaseUrl({
+        envBaseUrl: process.env.TEXTCORTEX_BASE_URL,
+        preferLocalhost,
+      }),
+      runtimeArgs.slice(1),
+      { preferLocalhost },
+    );
     return;
   }
 

package/scripts/run-zenocode.test.mjs

@@ -16,6 +16,7 @@ import {
   buildZenocodeBanner,
   chooseDefaults,
   hasLocalBaseUrlFlag,
+  resolveLoginBaseUrl,
   resolveLoginSuccessIdentifier,
   resolveTextCortexBaseUrl,
   runRuntimeWithSessionRecovery,
@@ -67,6 +68,34 @@ test("resolveTextCortexBaseUrl prefers localhost when the local flag is enabled"
   );
 });
 
+test("resolveLoginBaseUrl ignores stored credentials and defaults explicit login to cloud", () => {
+  assert.equal(
+    resolveLoginBaseUrl({
+      envBaseUrl: "",
+    }),
+    "https://api.textcortex.com",
+  );
+});
+
+test("resolveLoginBaseUrl still respects explicit env overrides", () => {
+  assert.equal(
+    resolveLoginBaseUrl({
+      envBaseUrl: "https://staging.textcortex.com",
+    }),
+    "https://staging.textcortex.com",
+  );
+});
+
+test("resolveLoginBaseUrl prefers localhost when the local flag is enabled", () => {
+  assert.equal(
+    resolveLoginBaseUrl({
+      envBaseUrl: "https://staging.textcortex.com",
+      preferLocalhost: true,
+    }),
+    "http://127.0.0.1:8080",
+  );
+});
+
 test("hasLocalBaseUrlFlag detects localhost flags", () => {
   assert.equal(hasLocalBaseUrlFlag(["login", "--local"]), true);
   assert.equal(hasLocalBaseUrlFlag(["--localhost", "run"]), true);