@textcortex/zenocode 0.1.13 → 0.1.14

package/README.md

@@ -4,6 +4,12 @@ Zenocode is the secure coding agent for TextCortex customers. It runs in your te
 
 Built for teams that need speed, control, and trust, Zenocode combines a terminal-native coding workflow with workspace routing and enterprise security from day one.
 
+## Requirements
+
+Zenocode is available on the **pay-as-you-go (PAYG)** plan. Your TextCortex account — or the organization seat assigned to you — must be on PAYG. On any other plan (Free, subscription, Business, Unlimited), `zenocode login` and model discovery return **"Zenocode is only available on the pay-as-you-go plan."** Switch your account (or ask your workspace admin to assign you a PAYG seat) before installing.
+
+If you already use pay-as-you-go and just ran out of wallet credits, top up under **Settings → Billing** (`/user/dashboard/settings/billing`). If you are not on pay-as-you-go yet, pick a plan on the **plan selection** page (`/billing/plans`). The in-app Zenocode dialog (sidebar → Zenocode) links you to the right one automatically based on your account.
+
 ## What This Package Does
 
 - Launches Zenocode from your terminal with the `zenocode` or `codecortex` command
@@ -31,13 +37,17 @@ The first `zenocode login` launches Zenocode automatically after browser authent
 
 If you already have an API key, you can also start Zenocode by setting `TEXTCORTEX_API_KEY` or `TEXTCORTEX_API_TOKEN`.
 
+## Models
+
+Zenocode uses **GPT-5.6 Luna** by default. You can switch to any other model available to your TextCortex workspace from the model picker inside the agent. Available models are discovered automatically from your account, so the default falls back to the next best coding model (for example Kimi K2.7 Code) when Luna is not available to you.
+
 ## Built For Security And Compliance
 
-Zenocode is built for organizations that treat security, compliance, and data sovereignty as non-negotiable.
+Zenocode is built for organizations that treat security, compliance, and data governance as non-negotiable.
 
-- Hosted in the European Union on GDPR-compliant infrastructure
+- TextCortex-managed routing with workspace-aware model availability
 - SOC 2 and ISO 27001 certified
-- Built for European data sovereignty
+- Model region metadata is surfaced for routing and governance decisions
 - Zero data training: your data is not used for model training or fine-tuning
 - Optional services or LLMs hosted outside the EU are covered by the EU-US Data Privacy Framework or GDPR Standard Contractual Clauses
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@textcortex/zenocode",
-  "version": "0.1.13",
-  "description": "Secure, EU-hosted coding agent for TextCortex customers that runs in your terminal, edits files, runs scripts, and more.",
+  "version": "0.1.14",
+  "description": "Secure, TextCortex-managed coding agent for customers that runs in your terminal, edits files, runs scripts, and more.",
   "keywords": [
     "ai",
     "agent",
@@ -11,12 +11,17 @@
     "developer-tools",
     "textcortex",
     "secure",
-    "eu-hosted",
+    "enterprise",
     "gdpr"
   ],
   "private": false,
   "license": "UNLICENSED",
   "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/textcortex/platform.git",
+    "directory": "apps/zenocode"
+  },
   "publishConfig": {
     "access": "public"
   },

package/scripts/build-branded-opencode.mjs

@@ -17,6 +17,10 @@ export const defaultOpenCodeForkUrl = "https://github.com/sst/opencode";
 export const defaultOpenCodeRef = openCodeRef;
 export const defaultOpenCodeVersion = openCodeVersion;
 export const defaultOpenCodeBuildArgs = ["--skip-install"];
+export const trustedPublishingRepository = {
+  type: "git",
+  url: "git+https://github.com/textcortex/platform.git",
+};
 const displayNameOnlyBrandingRefs = new Set([defaultOpenCodeRef]);
 
 const forkUrl =
@@ -46,6 +50,8 @@ const publishTag =
   process.env.ZENOCODE_PUBLISH_TAG ||
   process.env.CODECORTEX_PUBLISH_TAG ||
   "latest";
+const publishProvenance =
+  (process.env.ZENOCODE_NPM_PROVENANCE || process.env.CODECORTEX_NPM_PROVENANCE) === "1";
 const configuredBuildArgs = (
   process.env.ZENOCODE_OPENCODE_BUILD_ARGS ||
   process.env.CODECORTEX_OPENCODE_BUILD_ARGS ||
@@ -226,6 +232,20 @@ async function writeJson(filePath, payload) {
   await fs.writeFile(filePath, `${JSON.stringify(payload, null, 2)}\n`, "utf-8");
 }
 
+export function selectLatestTarball(entries) {
+  const tarballs = entries.filter((entry) => entry.endsWith(".tgz")).sort((left, right) => {
+    const leftVersion = left.match(/-(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)(?:\+.*)?\.tgz$/)?.[1];
+    const rightVersion = right.match(/-(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)(?:\+.*)?\.tgz$/)?.[1];
+    if (leftVersion && rightVersion) {
+      return compareSemver(leftVersion, rightVersion);
+    }
+    if (leftVersion) return 1;
+    if (rightVersion) return -1;
+    return left.localeCompare(right);
+  });
+  return tarballs[tarballs.length - 1] || null;
+}
+
 async function maybePublishedVersion(packageName) {
   const npmCommand = _command("npm");
   try {
@@ -249,15 +269,18 @@ async function maybePublishedVersion(packageName) {
 async function packPackage(packageDir) {
   const npmCommand = _command("npm");
   await run(npmCommand, ["pack"], { cwd: packageDir });
-  const tarballs = (await fs.readdir(packageDir)).filter((entry) => entry.endsWith(".tgz")).sort();
-  if (!tarballs.length) {
+  const tarball = selectLatestTarball(await fs.readdir(packageDir));
+  if (!tarball) {
     throw new Error(`npm pack did not produce a tarball in ${packageDir}`);
   }
-  return path.join(packageDir, tarballs[tarballs.length - 1]);
+  return path.join(packageDir, tarball);
 }
 
-export function buildPublishCommandArgs(tarballPath, { tag } = {}) {
+export function buildPublishCommandArgs(tarballPath, { tag, provenance = false } = {}) {
   const args = ["publish", tarballPath, "--access", "public"];
+  if (provenance) {
+    args.push("--provenance");
+  }
   if (tag) {
     args.push("--tag", tag);
   }
@@ -281,10 +304,68 @@ async function publishTarballIfNeeded(packageName, version, tarballPath, cwd) {
   }
 
   const npmCommand = _command("npm");
-  await run(npmCommand, buildPublishCommandArgs(tarballPath, { tag: publishTag }), { cwd });
+  await run(npmCommand, buildPublishCommandArgs(tarballPath, { tag: publishTag, provenance: publishProvenance }), { cwd });
   return { published: true, skipped: false };
 }
 
+async function readPublishTarget(packageDir) {
+  const pkg = await readJson(path.join(packageDir, "package.json"));
+  if (typeof pkg?.name !== "string" || typeof pkg?.version !== "string") {
+    throw new Error(`Invalid package metadata in ${packageDir}`);
+  }
+  const tarball = selectLatestTarball(await fs.readdir(packageDir));
+  if (!tarball) {
+    throw new Error(`Missing npm tarball in ${packageDir}`);
+  }
+  return {
+    packageName: pkg.name,
+    version: pkg.version,
+    tarballPath: path.join(packageDir, tarball),
+    cwd: packageDir,
+  };
+}
+
+async function publishExistingPackages(artifactDir) {
+  const packageRoot = path.join(artifactDir, "npm-binaries");
+  const entries = await fs.readdir(packageRoot, { withFileTypes: true });
+  const binaryPackageDirs = entries
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => path.join(packageRoot, entry.name))
+    .sort();
+  if (!binaryPackageDirs.length) {
+    throw new Error(`No existing binary packages found under ${packageRoot}`);
+  }
+
+  const targets = [];
+  for (const packageDir of binaryPackageDirs) {
+    targets.push(await readPublishTarget(packageDir));
+  }
+  targets.push(await readPublishTarget(path.join(artifactDir, "npm-package")));
+
+  const published = [];
+  const skipped = [];
+  for (const target of targets) {
+    const result = await publishTarballIfNeeded(
+      target.packageName,
+      target.version,
+      target.tarballPath,
+      target.cwd,
+    );
+    if (result.published) {
+      published.push(target.packageName);
+    } else if (result.skipped) {
+      skipped.push(target.packageName);
+    }
+  }
+
+  if (published.length) {
+    console.log(`Published packages: ${published.join(", ")}`);
+  }
+  if (skipped.length) {
+    console.log(`Skipped already-published packages: ${skipped.join(", ")}`);
+  }
+}
+
 function _binaryFilename() {
   return process.platform === "win32" ? "opencode.exe" : "opencode";
 }
@@ -534,6 +615,7 @@ async function buildWrapperPackage({
     version,
     license: "MIT",
     type: "commonjs",
+    repository: trustedPublishingRepository,
     bin: buildWrapperBinMap(packageName, binName),
     optionalDependencies: Object.fromEntries(
       binaryPackages.map((pkg) => [pkg.brandedName, pkg.version]),
@@ -588,6 +670,7 @@ async function prepareBinaryPackages({ distDir, artifactDir, runtimePackageName
     const targetDir = path.join(packageRoot, brandedName.replace("/", "__"));
     await fs.cp(sourceDir, targetDir, { recursive: true });
     pkg.name = brandedName;
+    pkg.repository = trustedPublishingRepository;
     await writeJson(path.join(targetDir, "package.json"), pkg);
     await patchBinaryAtPath(path.join(targetDir, "bin", _binaryFilename()));
 
@@ -641,21 +724,29 @@ async function main() {
     console.log("  ZENOCODE_OPENCODE_BUILD_ARGS  Additional args for upstream build script");
     console.log("  ZENOCODE_PUBLISH=1            Publish packages to npm");
     console.log(`  ZENOCODE_PUBLISH_TAG          npm tag (default: ${publishTag})`);
+    console.log("  --publish-existing            Publish tarballs from the output directory without rebuilding");
     console.log("  Legacy CODECORTEX_* env names are still accepted for compatibility.");
     return;
   }
 
+  const npmCommand = _command("npm");
+  await requireCommand(npmCommand);
+
+  const artifactDir = path.resolve(outputDir);
+
+  if (cliArgs.includes("--publish-existing")) {
+    await publishExistingPackages(artifactDir);
+    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"];

package/scripts/build-branded-opencode.test.mjs

@@ -10,6 +10,8 @@ import {
   defaultOpenCodeVersion,
   deriveOpenCodeVersionFromRef,
   mapBrandedBinaryPackageName,
+  selectLatestTarball,
+  trustedPublishingRepository,
 } from "./build-branded-opencode.mjs";
 
 test("branded OpenCode build defaults to the latest stable upstream release", () => {
@@ -49,7 +51,26 @@ test("buildWrapperBinMap includes package, opencode, and zenocode entrypoints",
   });
 });
 
-test("buildPublishCommandArgs omits npm provenance for runtime tarball publishing", () => {
+test("generated runtime packages point trusted publishing at this repository", () => {
+  assert.deepEqual(trustedPublishingRepository, {
+    type: "git",
+    url: "git+https://github.com/textcortex/platform.git",
+  });
+});
+
+test("buildPublishCommandArgs enables npm provenance for trusted publishing", () => {
+  assert.deepEqual(buildPublishCommandArgs("package.tgz", { tag: "latest", provenance: true }), [
+    "publish",
+    "package.tgz",
+    "--access",
+    "public",
+    "--provenance",
+    "--tag",
+    "latest",
+  ]);
+});
+
+test("buildPublishCommandArgs omits npm provenance unless requested", () => {
   assert.deepEqual(buildPublishCommandArgs("package.tgz", { tag: "latest" }), [
     "publish",
     "package.tgz",
@@ -68,3 +89,15 @@ test("buildPublishCommandArgs omits tag arguments when no tag is provided", () =
     "public",
   ]);
 });
+
+test("selectLatestTarball returns the sorted newest tarball", () => {
+  assert.equal(
+    selectLatestTarball([
+      "README.md",
+      "textcortex-zenocode-linux-x64-1.9.0.tgz",
+      "textcortex-zenocode-linux-x64-1.10.0.tgz",
+    ]),
+    "textcortex-zenocode-linux-x64-1.10.0.tgz",
+  );
+  assert.equal(selectLatestTarball(["README.md"]), null);
+});

package/scripts/run-zenocode.mjs

@@ -55,10 +55,18 @@ const opencodeBinaryPath =
 const oauthInitiatePath = "/internal/v2/fastapi/zenocode/oauth2/initiate";
 const oauthTokenPath = "/internal/v2/fastapi/zenocode/oauth2/token";
 const defaultOrder = [
+  "gpt-5-6-luna",
+  "kimi-k2p7-code-non-thinking",
+  "kimi-k2p7-code-thinking",
   "minimax-m3-thinking",
-  "kimi-k2-6",
+  "kimi-k2-6-non-thinking",
+  "kimi-k2-6-thinking",
+  "kimi-k2-5",
   "kimi-k2-5-thinking",
-  "glm-5-1",
+  "glm-5-2-non-thinking",
+  "glm-5-2-thinking",
+  "glm-5-1-non-thinking",
+  "glm-5-1-thinking",
   "gpt-5-2",
   "gpt-5-1",
   "gpt-5",
@@ -393,7 +401,8 @@ export function chooseDefaults(models) {
   const ids = Object.keys(models);
   if (!ids.length) throw new Error("No models were returned by the backend.");
   const model = defaultOrder.find((id) => ids.includes(id)) || ids[0];
-  const smallModel = ids.find((id) => id.includes("mini") || id.includes("haiku")) || model;
+  const smallModel =
+    ids.find((id) => id.includes("-mini") || id.includes("haiku")) || model;
   return { model, smallModel };
 }
 

package/scripts/run-zenocode.test.mjs

@@ -27,17 +27,60 @@ import {
   writePrivateJsonFile,
 } from "./run-zenocode.mjs";
 
-test("chooseDefaults prefers MiniMax M3 thinking for Zenocode", () => {
+test("chooseDefaults prefers GPT-5.6 Luna as the Zenocode default", () => {
   const defaults = chooseDefaults({
-    "glm-5-1": {},
-    "kimi-k2-6": {},
+    "kimi-k2p7-code-non-thinking": {},
+    "gpt-5-6-luna": {},
+    "glm-5-2-non-thinking": {},
     "minimax-m3-thinking": {},
     "gpt-5-2": {},
   });
 
   assert.deepEqual(defaults, {
-    model: "minimax-m3-thinking",
-    smallModel: "minimax-m3-thinking",
+    model: "gpt-5-6-luna",
+    smallModel: "gpt-5-6-luna",
+  });
+});
+
+test("chooseDefaults falls back to Kimi K2.7 Code when GPT-5.6 Luna is unavailable", () => {
+  const defaults = chooseDefaults({
+    "kimi-k2p7-code-non-thinking": {},
+    "glm-5-2-non-thinking": {},
+    "glm-5-1-non-thinking": {},
+    "kimi-k2-6-non-thinking": {},
+    "minimax-m3-thinking": {},
+    "gpt-5-2": {},
+  });
+
+  assert.deepEqual(defaults, {
+    model: "kimi-k2p7-code-non-thinking",
+    smallModel: "kimi-k2p7-code-non-thinking",
+  });
+});
+
+test("chooseDefaults prefers GLM 5.2 over GLM 5.1 for Zenocode fallback", () => {
+  const defaults = chooseDefaults({
+    "glm-5-1-non-thinking": {},
+    "glm-5-2-non-thinking": {},
+    "gpt-5-mini": {},
+  });
+
+  assert.deepEqual(defaults, {
+    model: "glm-5-2-non-thinking",
+    smallModel: "gpt-5-mini",
+  });
+});
+
+test("chooseDefaults falls back to explicit thinking variants when base models are absent", () => {
+  const defaults = chooseDefaults({
+    "kimi-k2p7-code-thinking": {},
+    "glm-5-2-non-thinking": {},
+    "kimi-k2-6-thinking": {},
+  });
+
+  assert.deepEqual(defaults, {
+    model: "kimi-k2p7-code-thinking",
+    smallModel: "kimi-k2p7-code-thinking",
   });
 });
 
@@ -584,9 +627,14 @@ test("prepare-only refreshes stored Zenocode credentials when the access token h
           textcortex: {
             models: {
               "minimax-m3-thinking": {},
-              "kimi-k2-6": {},
+              "kimi-k2-6-non-thinking": {},
+              "kimi-k2-6-thinking": {},
+              "kimi-k2-5": {},
               "kimi-k2-5-thinking": {},
-              "glm-5-1": {},
+              "glm-5-2-non-thinking": {},
+              "glm-5-2-thinking": {},
+              "glm-5-1-non-thinking": {},
+              "glm-5-1-thinking": {},
             },
           },
         }),
@@ -646,6 +694,11 @@ test("prepare-only refreshes stored Zenocode credentials when the access token h
     await fs.readFile(path.join(zenocodeHome, "opencode.jsonc"), "utf-8"),
   );
   assert.equal(savedConfig.model, "textcortex/minimax-m3-thinking");
+
+  const savedModels = JSON.parse(
+    await fs.readFile(path.join(zenocodeHome, "models.json"), "utf-8"),
+  );
+  assert.ok(savedModels.textcortex.models["glm-5-2-non-thinking"]);
 });
 
 test("login launches the runtime immediately with system TUI theming", async (t) => {
@@ -733,9 +786,14 @@ main().catch((error) => {
           textcortex: {
             models: {
               "minimax-m3-thinking": {},
-              "kimi-k2-6": {},
+              "kimi-k2-6-non-thinking": {},
+              "kimi-k2-6-thinking": {},
+              "kimi-k2-5": {},
               "kimi-k2-5-thinking": {},
-              "glm-5-1": {},
+              "glm-5-2-non-thinking": {},
+              "glm-5-2-thinking": {},
+              "glm-5-1-non-thinking": {},
+              "glm-5-1-thinking": {},
             },
           },
         }),
@@ -806,6 +864,11 @@ main().catch((error) => {
   assert.equal(opencodeConfig.theme, "system");
   assert.equal(opencodeConfig.model, "textcortex/minimax-m3-thinking");
 
+  const modelsConfig = JSON.parse(
+    await fs.readFile(path.join(zenocodeHome, "models.json"), "utf-8"),
+  );
+  assert.ok(modelsConfig.textcortex.models["glm-5-2-non-thinking"]);
+
   const tuiConfig = JSON.parse(
     await fs.readFile(runtimeInvocation.env.OPENCODE_TUI_CONFIG, "utf-8"),
   );