@textcortex/zenocode 0.1.11 → 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.11",
+  "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",

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;
 }
 
@@ -1578,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,
@@ -1596,7 +1608,7 @@ async function main() {
       runtimeArgs.slice(1),
       { preferLocalhost },
     );
-    return;
+    runtimeArgs = [];
   }
 
   if (subcommand === "logout") {
@@ -1626,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

@@ -134,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, {});
 });
@@ -581,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");