@textcortex/zenocode 0.1.10 → 0.1.12

package/README.md

@@ -21,13 +21,14 @@ npm install -g @textcortex/zenocode
 
 ```bash
 zenocode login --email you@company.com
-zenocode
 ```
 
 Use your work email when logging in so Zenocode can route you to the correct onboarding and SSO flow for your workspace domain, for example `companyA.textcortex.com`.
 
 If you skip `--email`, Zenocode will ask for it interactively during login.
 
+The first `zenocode login` launches Zenocode automatically after browser authentication succeeds. In later terminal sessions, start it again with `zenocode`.
+
 If you already have an API key, you can also start Zenocode by setting `TEXTCORTEX_API_KEY` or `TEXTCORTEX_API_TOKEN`.
 
 ## Built For Security And Compliance

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@textcortex/zenocode",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "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

@@ -29,6 +29,7 @@ const legacyRuntimeCredentialsPath = path.join(
 const logoutMarkerPath = path.join(runtimeDir, "logout-marker.json");
 const modelsPath = path.join(runtimeDir, "models.json");
 const configPath = path.join(runtimeDir, "opencode.jsonc");
+const tuiConfigPath = path.join(runtimeDir, "opencode.tui.json");
 const localBaseUrlDefault = "http://127.0.0.1:8080";
 const cloudBaseUrlDefault = "https://api.textcortex.com";
 const localBaseUrlFlags = new Set(["--local", "--localhost"]);
@@ -394,6 +395,8 @@ export function buildOpenCodeConfig({ baseUrl, providerID, model, smallModel })
   return {
     $schema: "https://opencode.ai/config.json",
     enabled_providers: [providerID],
+    // Keep the legacy theme key populated for older OpenCode builds.
+    theme: "system",
     model: `${providerID}/${model}`,
     small_model: `${providerID}/${smallModel}`,
     provider: {
@@ -415,6 +418,13 @@ export function buildOpenCodeConfig({ baseUrl, providerID, model, smallModel })
   };
 }
 
+export function buildOpenCodeTuiConfig() {
+  return {
+    $schema: "https://opencode.ai/tui.json",
+    theme: "system",
+  };
+}
+
 function unwrapData(payload) {
   if (payload && typeof payload === "object" && payload.data && typeof payload.data === "object") {
     return payload.data;
@@ -482,10 +492,12 @@ async function prepareRuntime(baseUrl, token) {
     model,
     smallModel,
   });
+  const tuiConfig = buildOpenCodeTuiConfig();
 
   await fs.mkdir(runtimeDir, { recursive: true });
   await fs.writeFile(modelsPath, `${JSON.stringify(payload, null, 2)}\n`, "utf-8");
   await fs.writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf-8");
+  await fs.writeFile(tuiConfigPath, `${JSON.stringify(tuiConfig, null, 2)}\n`, "utf-8");
   return model;
 }
 
@@ -576,6 +588,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}.`,
@@ -1568,7 +1590,7 @@ async function main() {
   }
 
   const preferLocalhost = hasLocalBaseUrlFlag(passthrough);
-  const runtimeArgs = stripLocalBaseUrlFlags(passthrough);
+  let runtimeArgs = stripLocalBaseUrlFlags(passthrough);
   const storedBaseUrl = await resolveStoredBaseUrl();
   const baseUrl = resolveTextCortexBaseUrl({
     envBaseUrl: process.env.TEXTCORTEX_BASE_URL,
@@ -1578,8 +1600,15 @@ async function main() {
   const subcommand = runtimeArgs[0];
 
   if (subcommand === "login") {
-    await runLoginCommand(baseUrl, runtimeArgs.slice(1), { preferLocalhost });
-    return;
+    await runLoginCommand(
+      resolveLoginBaseUrl({
+        envBaseUrl: process.env.TEXTCORTEX_BASE_URL,
+        preferLocalhost,
+      }),
+      runtimeArgs.slice(1),
+      { preferLocalhost },
+    );
+    runtimeArgs = [];
   }
 
   if (subcommand === "logout") {
@@ -1609,6 +1638,7 @@ async function main() {
       ...process.env,
       OPENCODE_MODELS_PATH: modelsPath,
       OPENCODE_CONFIG: configPath,
+      OPENCODE_TUI_CONFIG: tuiConfigPath,
       TEXTCORTEX_API_KEY: token,
     },
   };

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);
@@ -105,6 +134,7 @@ test("buildOpenCodeConfig includes an openai stub for fallback runtime auth plug
 
   assert.deepEqual(config.enabled_providers, ["textcortex"]);
   assert.equal(config.model, "textcortex/kimi-k2-5-thinking");
+  assert.equal(config.theme, "system");
   assert.ok(config.provider.openai);
   assert.deepEqual(config.provider.openai.models, {});
 });
@@ -552,6 +582,167 @@ test("prepare-only refreshes stored Zenocode credentials when the access token h
   assert.equal(savedCredentials.refresh_token, "fresh-refresh");
 });
 
+test("login launches the runtime immediately with system TUI theming", async (t) => {
+  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "zenocode-login-"));
+  const zenocodeHome = path.join(tempDir, ".zenocode");
+  const runtimeLogPath = path.join(tempDir, "runtime-log.json");
+  const fakeRuntimePath = path.join(tempDir, "fake-opencode");
+  const scriptPath = new URL("./run-zenocode.mjs", import.meta.url);
+
+  t.after(async () => {
+    await fs.rm(tempDir, { recursive: true, force: true });
+  });
+
+  await fs.mkdir(zenocodeHome, { recursive: true });
+  await fs.writeFile(
+    fakeRuntimePath,
+    `#!/usr/bin/env node
+const fs = require("node:fs/promises");
+
+async function main() {
+  const payload = {
+    args: process.argv.slice(2),
+    env: {
+      OPENCODE_CONFIG: process.env.OPENCODE_CONFIG,
+      OPENCODE_TUI_CONFIG: process.env.OPENCODE_TUI_CONFIG,
+      TEXTCORTEX_API_KEY: process.env.TEXTCORTEX_API_KEY,
+    },
+  };
+  await fs.writeFile(process.env.RUNTIME_LOG_PATH, JSON.stringify(payload), "utf-8");
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});
+`,
+    "utf-8",
+  );
+  await fs.chmod(fakeRuntimePath, 0o755);
+
+  const server = http.createServer((req, res) => {
+    if (
+      req.method === "POST" &&
+      req.url === "/internal/v1/fastapi/zenocode/oauth2/initiate"
+    ) {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({
+          data: {
+            device_code: "device-code",
+            user_code: "ABCD-1234",
+            verification_url_complete: "https://textcortex.example/verify",
+            interval: 0,
+            expires_in: 30,
+          },
+        }),
+      );
+      return;
+    }
+
+    if (
+      req.method === "POST" &&
+      req.url === "/internal/v1/fastapi/zenocode/oauth2/token"
+    ) {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({
+          data: {
+            access_token: "fresh-access",
+            refresh_token: "fresh-refresh",
+            auth_id: "auth_123",
+          },
+        }),
+      );
+      return;
+    }
+
+    if (
+      req.method === "GET" &&
+      req.url === "/internal/v1/fastapi/zenocode/models/api.json"
+    ) {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({
+          textcortex: {
+            models: {
+              "kimi-k2-5-thinking": {},
+              "glm-5": {},
+            },
+          },
+        }),
+      );
+      return;
+    }
+
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ detail: "not found" }));
+  });
+
+  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+  const address = server.address();
+  const baseUrl = `http://127.0.0.1:${address.port}`;
+
+  t.after(async () => {
+    await new Promise((resolve, reject) =>
+      server.close((error) => (error ? reject(error) : resolve())),
+    );
+  });
+
+  const result = await new Promise((resolve, reject) => {
+    const child = spawn(
+      process.execPath,
+      [
+        scriptPath.pathname,
+        "login",
+        "--email",
+        "person@example.com",
+        "--no-launch-browser",
+      ],
+      {
+        cwd: tempDir,
+        env: {
+          ...process.env,
+          ZENOCODE_HOME: zenocodeHome,
+          ZENOCODE_NO_BANNER: "1",
+          ZENOCODE_OPENCODE_BIN_PATH: fakeRuntimePath,
+          TEXTCORTEX_BASE_URL: baseUrl,
+          RUNTIME_LOG_PATH: runtimeLogPath,
+        },
+        stdio: ["ignore", "pipe", "pipe"],
+      },
+    );
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    child.on("error", reject);
+    child.on("exit", (code, signal) => resolve({ code, signal, stdout, stderr }));
+  });
+
+  assert.equal(result.code, 0);
+  assert.match(result.stdout, /Login successful for auth_123/);
+  assert.match(result.stdout, /Zenocode config ready at/);
+
+  const runtimeInvocation = JSON.parse(await fs.readFile(runtimeLogPath, "utf-8"));
+  assert.deepEqual(runtimeInvocation.args, []);
+  assert.equal(runtimeInvocation.env.TEXTCORTEX_API_KEY, "fresh-access");
+
+  const opencodeConfig = JSON.parse(
+    await fs.readFile(runtimeInvocation.env.OPENCODE_CONFIG, "utf-8"),
+  );
+  assert.equal(opencodeConfig.theme, "system");
+
+  const tuiConfig = JSON.parse(
+    await fs.readFile(runtimeInvocation.env.OPENCODE_TUI_CONFIG, "utf-8"),
+  );
+  assert.equal(tuiConfig.theme, "system");
+});
+
 test("logout removes runtime credentials and blocks shared fallback credentials", async (t) => {
   const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "zenocode-logout-"));
   const zenocodeHome = path.join(tempDir, ".zenocode");