@linxiraos/main 1.2.0 → 1.3.1

package/README.md

@@ -1,26 +1,60 @@
-# zeta — the Zeta workspace
+# zetawork — the Zeta workspace
 
-One terminal, many tools: `zeta` opens a nested-terminal workbench — top-level
-tabs, tiled panes of real embedded terminals (PTY children), and a menu of the
-Zeta suite. Type `zeta` in a project directory and everything is one key away:
+One terminal, many tools: `zetawork` opens a nested-terminal workbench —
+top-level tabs, tiled panes of real embedded terminals (PTY children), and a
+menu of the Zeta suite. Type `zetawork` in a project directory and everything
+is one key away:
 
-- `Alt+C` — a pane running `zeta-c` (the coding agent)
-- `Alt+E` — a pane running `zeta-e` (the terminal editor)
+- `Alt+C` — a pane running `zetacode` (the coding agent)
+- `Alt+E` — the built-in editor pane (no separate editor command exists)
 - `Alt+N` / `Alt+S` — a plain shell pane
 - `Alt+T` / `Alt+1..9` — new tab / jump between tabs (each tab keeps its own
   layout)
 - `Alt+L` — cycle the pane layout (1x1, side-by-side, 2x2)
-- `F1` — in-app help; `zeta --help` — the same map on the command line
+- `F1` — in-app help; `zetawork --help` — the same map on the command line
 
-Every tool also runs standalone (`zeta-c`, `zeta-editor`/`zeta-e`,
-`zeta-ide`/`zeta-i`, each with its own `--help`).
+A bare `zeta` is the suite index: it prints the help that lists `zetawork`,
+`zetacode`, and `zetaide`. `zetawork web` serves the full Web UI on loopback
+for your browser. Every command also runs standalone (`zetawork`, `zetacode`,
+`zetaide`, each with its own `--help`).
 
 The workspace is Rust (ratatui + portable-pty via the vendored TermIDE panel
 crates). This tree is its own Cargo workspace — `cargo build` inside `main/`.
 
 ## npm distribution
 
-`@linxiraos/main` (bin `zeta`) with `@linxiraos/main-windows-x64` /
-`@linxiraos/main-linux-x64` platform leaves, mirroring the editor and ide
-packages. Platform binaries are built locally and committed into the leaf
-`bin/` directories before a release.
+`@linxiraos/main` (bins `zetawork` and `zeta`) with
+`@linxiraos/main-windows-x64` / `@linxiraos/main-linux-x64` platform leaves,
+mirroring the editor and ide packages. Platform binaries are built locally and
+committed into the leaf `bin/` directories before a release.
+
+### Companions: zetacode and zetaide ship with zetawork
+
+Installing the workbench installs the whole suite: the same
+`optionalDependencies` block that pins the platform leaves also pins
+`@linxiraos/zeta` (bin `zetacode`) and `@linxiraos/ide` (bin `zetaide`) at this
+package's own version. npm therefore materializes all three products under
+`node_modules/@linxiraos/`:
+
+| Product    | npm package / binary                                                   |
+| ---------- | ---------------------------------------------------------------------- |
+| `zetawork` | `@linxiraos/main-windows-x64/bin/zeta.exe` · `@linxiraos/main-linux-x64/bin/zeta-linux-x64` |
+| `zetacode` | `@linxiraos/zeta` (published bin `zetacode` → `dist/cli.js`)            |
+| `zetaide`  | `@linxiraos/ide-windows-x64/bin/termide.exe` · `@linxiraos/ide-linux-x64/bin/termide-linux-x64` |
+
+**Why `optionalDependencies` and not `dependencies`.** Two reasons, and they
+are the same two that govern the platform leaves:
+
+- the companions are pinned to an **exact** version, so make no sense as a
+  range; the repo's one-version-line rule makes an exact pin the honest form;
+- an install must never fail because one companion is unavailable for the
+  host. The companion packages carry their own `os`/`cpu`-gated leaves
+  (`os: ["win32"]` / `os: ["linux"]`, `cpu: ["x64"]`), so npm skips the
+  foreign binary — a Linux install never drags a Windows `.exe` — and a
+  registry/skip failure degrades to a missing command with a resolver message
+  instead of aborting the whole workbench install.
+
+No binary is duplicated into a leaf: the workbench binary stays in
+`main-<platform>-x64`, `zetacode` stays in `@linxiraos/zeta`, `zetaide` stays in
+`@linxiraos/ide-<platform>-x64`. `scripts/check-workbench-bundles.ts` guards the
+declaration and the release/packaging steps that carry it.

package/bin/launch.js

@@ -0,0 +1,156 @@
+"use strict";
+// Shared launcher for the workbench's two bins (`zetawork`, `zeta`): unified
+// binary discovery, npm-form face:
+//   ① explicit env  — ZETA_BIN_DIR (delimiter-separated dirs, probed first)
+//   ② PATH          — a *native* zetawork/zeta binary (distro pacman install
+//                     or a real .exe); PATH hits are used as-is, with no
+//                     cross-component version validation
+//   ③ npm vendored  — the platform-leaf binary shipped as
+//                     @linxiraos/main-<platform>-<arch> (same pattern as the
+//                     zetaide launcher), then the repo target/release location
+//                     for source checkouts
+//
+// The two bins exec the same native binary, and only the *entry* differs: a
+// bare `zetawork` opens the workspace, a bare `zeta` prints the suite index
+// (`--help`). The entry therefore travels as an explicit argv token
+// (`--zeta-entry=<name>`) the binary strips before any other parsing — npm's
+// shims all exec one file, so argv[0] cannot carry it.
+// Node-only, no Bun needed.
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { spawn } = require("node:child_process");
+
+// npm package names use "windows"; Node's process.platform is "win32".
+const PKG_PLATFORM = process.platform === "win32" ? "windows" : process.platform;
+const PKG_PREFIX = "@linxiraos/main-";
+const EXE = process.platform === "win32" ? "zeta.exe" : "zeta-linux-x64";
+const NATIVE_BINS = ["zetawork", "zeta"];
+
+/** Entry tokens the native binary understands (see main.rs `entry_of`). */
+const ENTRY_WORKBENCH = "workbench";
+const ENTRY_INDEX = "zeta";
+
+function die(msg) {
+  process.stderr.write(`zetawork: ${msg}\n`);
+  process.exit(1);
+}
+
+/** Native-executable test so PATH probes never pick up another JS shim
+ * (npm's .cmd/.ps1/sh launchers for this very package live on PATH —
+ * re-executing them would recurse into this script). POSIX also demands
+ * the exec bit: a non-executable ELF (broken extract, cache artifact)
+ * would only die later with a raw spawn EACCES. */
+function isNativeBinary(candidate) {
+  let stat;
+  try {
+    stat = fs.statSync(candidate);
+  } catch {
+    return false;
+  }
+  if (!stat.isFile()) return false;
+  if (process.platform === "win32") {
+    return candidate.toLowerCase().endsWith(".exe");
+  }
+  if (!isExecutable(candidate)) return false;
+  let head;
+  try {
+    const fd = fs.openSync(candidate, "r");
+    const buf = Buffer.alloc(4);
+    const read = fs.readSync(fd, buf, 0, 4, 0);
+    fs.closeSync(fd);
+    head = read === 4 ? buf : null;
+  } catch {
+    return false;
+  }
+  return head !== null && head.equals(Buffer.from([0x7f, 0x45, 0x4c, 0x46])); // \x7fELF
+}
+
+/** POSIX exec-bit probe; Windows access(X_OK) always succeeds, which is
+ * fine there — a named .exe is the platform's native form. */
+function isExecutable(candidate) {
+  try {
+    fs.accessSync(candidate, fs.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Native executable candidates for one bin name per directory entry:
+ * `name.exe` on Windows, the bare ELF name elsewhere. */
+function nativeCandidates(dir, name) {
+  return process.platform === "win32" ? [path.join(dir, `${name}.exe`)] : [path.join(dir, name)];
+}
+
+/** First native hit for the workbench bins inside `dirs`, or null. */
+function findNativeIn(dirs) {
+  for (const dir of dirs) {
+    if (!dir) continue;
+    for (const name of NATIVE_BINS) {
+      for (const candidate of nativeCandidates(dir, name)) {
+        if (isNativeBinary(candidate)) return candidate;
+      }
+    }
+  }
+  return null;
+}
+
+function explicitDirs() {
+  const raw = process.env.ZETA_BIN_DIR;
+  if (!raw) return [];
+  return raw.split(path.delimiter).map((dir) => dir.trim()).filter((dir) => dir.length > 0);
+}
+
+/** Windows env blocks carry `Path`, POSIX `PATH` — accept either spelling. */
+function pathDirs() {
+  const raw = process.env.PATH ?? process.env.Path;
+  return (raw || "").split(path.delimiter);
+}
+
+/** Resolve the native binary, or exit with the install hint. */
+function resolveBinary() {
+  // ① explicit env → ② PATH (native binaries only)
+  const fromNative = findNativeIn([...explicitDirs(), ...pathDirs()]);
+  if (fromNative) return fromNative;
+
+  // ③ npm vendored platform leaf. A resolved but non-executable leaf
+  // (broken extract, cache artifact) must fall through to the install
+  // hint instead of dying later with a raw spawn EACCES.
+  try {
+    const leaf = require.resolve(`${PKG_PREFIX}${PKG_PLATFORM}-${process.arch}/bin/${EXE}`);
+    if (process.platform === "win32" || isExecutable(leaf)) return leaf;
+  } catch {
+    // Fall back to a repo-layout location (dev / source checkout):
+    // <repo>/main/target/release/<exe> next to this package.
+    const local = path.join(__dirname, "..", "..", "..", "target", "release", EXE);
+    if (fs.existsSync(local) && (process.platform === "win32" || isExecutable(local))) return local;
+  }
+
+  die(
+    `no native zetawork/zeta on PATH and no binary for ${process.platform}-${process.arch}; ` +
+      `install @linxiraos/main (supported: windows-x64, linux-x64) ` +
+      `or build from source with \`cargo build --release\` in the main/ workspace`,
+  );
+}
+
+/** Exec the workspace binary for one entry name (`workbench` | `zeta`),
+ * forwarding `argv` and the entry token. */
+function launch(entry, argv) {
+  if (entry !== ENTRY_WORKBENCH && entry !== ENTRY_INDEX) {
+    die(`unknown entry \`${entry}\` (expected ${ENTRY_WORKBENCH} or ${ENTRY_INDEX})`);
+  }
+  const bin = resolveBinary();
+  const args = [`--zeta-entry=${entry}`, ...argv];
+  const child = spawn(bin, args, { stdio: "inherit" });
+  child.on("error", (err) => die(String(err)));
+  child.on("close", (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+    } else {
+      process.exit(code ?? 0);
+    }
+  });
+}
+
+module.exports = { launch, ENTRY_INDEX, ENTRY_WORKBENCH, NATIVE_BINS };

package/bin/zeta.js

@@ -1,135 +1,8 @@
 #!/usr/bin/env node
-// zeta launcher — unified binary discovery, npm-form face:
-//   ① explicit env  — ZETA_BIN_DIR (delimiter-separated dirs, probed first)
-//   ② PATH          — a *native* zetawork/zeta binary (distro pacman install
-//                     or a real .exe); PATH hits are used as-is, with no
-//                     cross-component version validation
-//   ③ npm vendored  — the platform-leaf binary shipped as
-//                     @linxiraos/main-<platform>-<arch> (same pattern as the
-//                     zeta-ide / zeta-editor launchers), then the repo
-//                     target/release location for source checkouts
-// Node-only, no Bun needed.
+"use strict";
+// `zeta` — the suite index bin: a bare invocation prints the help that lists
+// `zetawork`, `zetacode` and `zetaide` (the workspace itself opens with
+// `zetawork`).
+const { launch, ENTRY_INDEX } = require("./launch");
 
-const fs = require("node:fs");
-const path = require("node:path");
-const { spawn } = require("node:child_process");
-
-// npm package names use "windows"; Node's process.platform is "win32".
-const PKG_PLATFORM = process.platform === "win32" ? "windows" : process.platform;
-const PKG_PREFIX = "@linxiraos/main-";
-const EXE = process.platform === "win32" ? "zeta.exe" : "zeta-linux-x64";
-const NATIVE_BINS = ["zetawork", "zeta", "zeta-work"];
-
-function die(msg) {
-  process.stderr.write(`zeta: ${msg}\n`);
-  process.exit(1);
-}
-
-/** Native-executable test so PATH probes never pick up another JS shim
- * (npm's .cmd/.ps1/sh launchers for this very package live on PATH —
- * re-executing them would recurse into this script). POSIX also demands
- * the exec bit: a non-executable ELF (broken extract, cache artifact)
- * would only die later with a raw spawn EACCES. */
-function isNativeBinary(candidate) {
-  let stat;
-  try {
-    stat = fs.statSync(candidate);
-  } catch {
-    return false;
-  }
-  if (!stat.isFile()) return false;
-  if (process.platform === "win32") {
-    return candidate.toLowerCase().endsWith(".exe");
-  }
-  if (!isExecutable(candidate)) return false;
-  let head;
-  try {
-    const fd = fs.openSync(candidate, "r");
-    const buf = Buffer.alloc(4);
-    const read = fs.readSync(fd, buf, 0, 4, 0);
-    fs.closeSync(fd);
-    head = read === 4 ? buf : null;
-  } catch {
-    return false;
-  }
-  return head !== null && head.equals(Buffer.from([0x7f, 0x45, 0x4c, 0x46])); // \x7fELF
-}
-
-/** POSIX exec-bit probe; Windows access(X_OK) always succeeds, which is
- * fine there — a named .exe is the platform's native form. */
-function isExecutable(candidate) {
-  try {
-    fs.accessSync(candidate, fs.constants.X_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/** Native executable candidates for one bin name per directory entry:
- * `name.exe` on Windows, the bare ELF name elsewhere. */
-function nativeCandidates(dir, name) {
-  return process.platform === "win32" ? [path.join(dir, `${name}.exe`)] : [path.join(dir, name)];
-}
-
-/** First native hit for the workbench bins inside `dirs`, or null. */
-function findNativeIn(dirs) {
-  for (const dir of dirs) {
-    if (!dir) continue;
-    for (const name of NATIVE_BINS) {
-      for (const candidate of nativeCandidates(dir, name)) {
-        if (isNativeBinary(candidate)) return candidate;
-      }
-    }
-  }
-  return null;
-}
-
-function explicitDirs() {
-  const raw = process.env.ZETA_BIN_DIR;
-  if (!raw) return [];
-  return raw.split(path.delimiter).map((dir) => dir.trim()).filter((dir) => dir.length > 0);
-}
-
-/** Windows env blocks carry `Path`, POSIX `PATH` — accept either spelling. */
-function pathDirs() {
-  const raw = process.env.PATH ?? process.env.Path;
-  return (raw || "").split(path.delimiter);
-}
-
-// ① explicit env → ② PATH (native binaries only)
-const fromNative = findNativeIn([...explicitDirs(), ...pathDirs()]);
-
-let bin = fromNative;
-if (!bin) {
-  // ③ npm vendored platform leaf. A resolved but non-executable leaf
-  // (broken extract, cache artifact) must fall through to the install
-  // hint instead of dying later with a raw spawn EACCES.
-  try {
-    const leaf = require.resolve(`${PKG_PREFIX}${PKG_PLATFORM}-${process.arch}/bin/${EXE}`);
-    if (process.platform === "win32" || isExecutable(leaf)) bin = leaf;
-  } catch {
-    // Fall back to a repo-layout location (dev / source checkout):
-    // <repo>/main/target/release/<exe> next to this package.
-    const local = path.join(__dirname, "..", "..", "..", "target", "release", EXE);
-    if (fs.existsSync(local) && (process.platform === "win32" || isExecutable(local))) bin = local;
-  }
-}
-
-if (!bin) {
-  die(
-    `no native zetawork/zeta on PATH and no binary for ${process.platform}-${process.arch}; ` +
-      `install @linxiraos/main (supported: windows-x64, linux-x64) ` +
-      `or build from source with \`cargo build --release\` in the main/ workspace`,
-  );
-}
-
-const child = spawn(bin, process.argv.slice(2), { stdio: "inherit" });
-child.on("error", (err) => die(String(err)));
-child.on("close", (code, signal) => {
-  if (signal) {
-    process.kill(process.pid, signal);
-  } else {
-    process.exit(code ?? 0);
-  }
-});
+launch(ENTRY_INDEX, process.argv.slice(2));

package/bin/zetawork.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+"use strict";
+// `zetawork` — the workbench bin: a bare invocation opens the workspace.
+const { launch, ENTRY_WORKBENCH } = require("./launch");
+
+launch(ENTRY_WORKBENCH, process.argv.slice(2));

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@linxiraos/main",
-  "version": "1.2.0",
+  "version": "1.3.1",
   "description": "zeta — the Zeta workspace: a nested-terminal workbench with tabs, panes, and the Zeta tool suite",
-  "license": "MIT",
+  "license": "AGPL-3.0-only",
   "publishConfig": {
     "access": "public"
   },
@@ -12,9 +12,8 @@
     "directory": "main"
   },
   "bin": {
-    "zeta": "bin/zeta.js",
-    "zetawork": "bin/zeta.js",
-    "zeta-work": "bin/zeta.js"
+    "zetawork": "bin/zetawork.js",
+    "zeta": "bin/zeta.js"
   },
   "files": [
     "bin/",
@@ -22,8 +21,10 @@
     "README.md"
   ],
   "optionalDependencies": {
-    "@linxiraos/main-windows-x64": "1.2.0",
-    "@linxiraos/main-linux-x64": "1.2.0"
+    "@linxiraos/main-windows-x64": "1.3.1",
+    "@linxiraos/main-linux-x64": "1.3.1",
+    "@linxiraos/zeta": "1.3.1",
+    "@linxiraos/ide": "1.3.1"
   },
   "engines": {
     "node": ">=18"