nyte-ai 0.0.1 → 0.0.7

package/README.md

@@ -1,24 +1,26 @@
 # nyte-ai
 
-`nyte-ai` is the executable distribution for Nyte, a client/server coding-agent platform with a headless host and terminal client. It installs the `nyte` command.
+`nyte-ai` installs the `nyte` command, the terminal client for Nyte.
 
-## Status
-
-This preview establishes the Nyte CLI distribution. It does not start an agent or server yet.
-
-The planned command shape is:
+Run it without installing:
 
 ```sh
-npx nyte-ai        # open the terminal client
-npx nyte-ai serve  # run the standalone headless server
+npx nyte-ai
 ```
 
-The installed command uses the same entry point:
+Or install it globally:
 
 ```sh
 npm install --global nyte-ai
 nyte
-nyte serve
 ```
 
-The published `nyte-ai` package will compose the Nyte terminal client with the headless host. It will not carry a second implementation of either package.
+The npm package downloads the matching release from
+[`interfaces-lab/nyte`](https://github.com/interfaces-lab/nyte), verifies its SHA-256 checksum,
+and caches the native executable under `~/.nyte/bin`. Set `NYTE_BIN_DIR` to choose another cache
+directory.
+
+Read the [included guide and runnable examples](docs/README.md). These files ship
+with this npm version. For a global install, the guide is at
+`$(npm root -g)/nyte-ai/docs/README.md`. A downloaded native release also retains
+its guide at `<cache-directory>/<version>/docs/README.md`.

package/bin/nyte.js

@@ -1,26 +1,10 @@
 #!/usr/bin/env node
 
-const VERSION = "0.0.1";
-const HELP = `nyte
+import { launch } from "../src/launcher.js";
 
-Headless agent runner and terminal client for Nyte
-
-Usage:
-  nyte          Open the terminal client
-  nyte serve    Run the standalone headless server
-
-Status:
-  This preview establishes the Nyte CLI distribution. The runner is not released yet.`;
-
-const args = process.argv.slice(2);
-if (args.includes("--version") || args.includes("-v")) {
-  process.stdout.write(`${VERSION}\n`);
-} else if (args.includes("--help") || args.includes("-h")) {
-  process.stdout.write(`${HELP}\n`);
-} else {
-  process.stderr.write(
-    "Nyte is not available yet. This preview establishes the upcoming headless runner and terminal client distribution.\n",
-  );
-  process.stderr.write("Run `npx nyte-ai --help` to see the planned command shape.\n");
+try {
+  process.exitCode = await launch();
+} catch (error) {
+  process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
   process.exitCode = 1;
 }

package/docs/README.md

@@ -0,0 +1,16 @@
+# Nyte guide
+
+This guide and its source examples ship with the Nyte release you installed.
+The npm package records its version in `package.json`; a native archive records
+it in `VERSION` beside the executable.
+
+- [Run a conversation or one prompt](usage.md)
+- [Source examples](examples/README.md)
+
+For npm installs, this guide is inside `nyte-ai/docs`. For native installs it is
+at `<install-directory>/../share/nyte/<version>/docs/README.md`. The default is
+`~/.local/share/nyte/<version>/docs/README.md`. An unpacked archive has `docs`
+beside `nyte`. Keep the docs for the executable version you use.
+
+Nyte's workspace libraries are private. These examples use the installed `nyte`
+command and do not require unpublished packages.

package/docs/examples/README.md

@@ -0,0 +1,18 @@
+# Source examples
+
+Run these from the workspace you want Nyte to inspect, after login and workspace
+trust setup. Put `nyte` on `PATH`. Each script starts one prompt run and
+returns Nyte's exit status. Neither script changes your shell settings.
+
+- [ask.sh](ask.sh) passes prompt arguments without shell evaluation.
+- [prompt-file.sh](prompt-file.sh) reads a prompt from a UTF-8 text file through stdin.
+
+Replace `/path/to/docs` with this guide's installed directory:
+
+```sh
+sh /path/to/docs/examples/ask.sh "Summarize this project's README"
+sh /path/to/docs/examples/prompt-file.sh ./prompt.txt
+```
+
+These are ordinary shell source files you can copy and adapt. See the
+[usage guide](../usage.md) for setup and the [front door](../README.md) for locations.

package/docs/examples/ask.sh

@@ -0,0 +1,7 @@
+#!/bin/sh
+set -eu
+if [ "$#" -eq 0 ]; then
+	echo "Usage: ask.sh <prompt>" >&2
+	exit 2
+fi
+exec nyte --print -- "$@"

package/docs/examples/prompt-file.sh

@@ -0,0 +1,7 @@
+#!/bin/sh
+set -eu
+if [ "$#" -ne 1 ]; then
+	echo "Usage: prompt-file.sh <prompt-file>" >&2
+	exit 2
+fi
+exec nyte --print <"$1"

package/docs/usage.md

@@ -0,0 +1,47 @@
+# Run Nyte
+
+Log in once, then start a conversation from your project directory:
+
+```sh
+nyte login
+nyte
+```
+
+`nyte login` lists the providers you can sign in to. `nyte login github-copilot` signs in with a
+GitHub device code: open the URL it prints, enter the code, and Nyte loads the models your Copilot
+account can use. This uses the GitHub Copilot OAuth app used by Pi, not a Nyte or OpenCode app.
+Nyte exchanges the GitHub token for a short-lived Copilot session token and refreshes it as needed.
+Existing direct-token Copilot logins need a fresh sign-in after upgrading. Nyte is not an officially
+supported Copilot client; the account needs Copilot access.
+
+Nyte asks whether you trust the directory. A trusted workspace lets tools read,
+edit, and run commands with your process's access. There are no per-tool prompts.
+Use an isolated environment when the workspace needs stronger boundaries.
+
+To send one prompt and exit:
+
+```sh
+nyte --print -- "Summarize this project's README"
+```
+
+Use `--provider <provider>` and `--model <model>` before `--` to select a model.
+These requests use your configured provider and may incur charges. Run `nyte login`
+interactively before using scripts. A script must also run in a trusted workspace.
+
+Use `nyte --resume` in a terminal to continue the latest conversation.
+Installed copies can update with `nyte update`.
+That command currently updates only the executable; it does not install the new
+release's docs. Run the installer for that version to install its matching docs.
+
+## Delegated tasks
+
+The agent waits for a delegated task by default. It can start independent work in the
+background, then use `wait_task` with that job's ID when it needs the report. The parent
+continues after the existing task finishes; it does not launch a replacement or poll.
+`stop_task` cancels the task. These are agent tools, not terminal commands.
+
+A background report cannot restart a finished or stopped conversation. If the parent
+already finished, the report stays queued for your next message.
+
+The [source examples](examples/README.md) demonstrate quoted arguments and stdin.
+Return to the [guide](README.md).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nyte-ai",
-  "version": "0.0.1",
+  "version": "0.0.7",
   "description": "Headless agent runner and terminal client for Nyte",
   "keywords": [
     "agent",
@@ -9,23 +9,33 @@
     "coding-agent",
     "headless"
   ],
-  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/interfaces-lab/nyte.git",
+    "directory": "packages/cli"
+  },
   "bin": {
     "nyte": "bin/nyte.js"
   },
   "files": [
     "bin",
+    "docs",
+    "src",
     "README.md"
   ],
   "type": "module",
   "publishConfig": {
     "access": "public"
   },
+  "scripts": {
+    "clean": "rm -rf node_modules .turbo dist",
+    "package": "pnpm pack --pack-destination dist",
+    "test": "vitest --run"
+  },
+  "devDependencies": {
+    "vitest": "^5.0.0"
+  },
   "engines": {
     "node": ">=26"
-  },
-  "scripts": {
-    "clean": "rm -rf node_modules .turbo",
-    "test": "node --test"
   }
-}
+}

package/src/launcher.js

@@ -0,0 +1,121 @@
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { chmod, mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import process from "node:process";
+
+export const REPOSITORY = "interfaces-lab/nyte";
+
+export function platformTarget(platform = process.platform, arch = process.arch) {
+  if ((platform !== "darwin" && platform !== "linux") || (arch !== "arm64" && arch !== "x64")) {
+    return undefined;
+  }
+  return `${platform}-${arch}`;
+}
+
+export function releaseAssetName(version, target) {
+  return `nyte-v${version.replace(/^v/u, "")}-${target}`;
+}
+
+async function packageVersion() {
+  const metadata = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"));
+  if (typeof metadata.version !== "string") throw new Error("nyte-ai has no package version.");
+  return metadata.version;
+}
+
+export function cacheRoot(env = process.env) {
+  return env["NYTE_BIN_DIR"] ?? join(homedir(), ".nyte", "bin");
+}
+
+async function sha256(path) {
+  const hash = createHash("sha256");
+  hash.update(await readFile(path));
+  return hash.digest("hex");
+}
+
+async function fetchOk(fetchFn, url) {
+  const response = await fetchFn(url, { signal: AbortSignal.timeout(10 * 60_000) });
+  if (!response.ok) throw new Error(`Failed to download ${url} (HTTP ${response.status}).`);
+  return response;
+}
+
+async function download(fetchFn, url, path) {
+  const response = await fetchOk(fetchFn, url);
+  await writeFile(path, new Uint8Array(await response.arrayBuffer()));
+}
+
+export async function ensureBinary(options = {}) {
+  const version = options.version ?? (await packageVersion());
+  const target = platformTarget(options.platform, options.arch);
+  if (target === undefined) {
+    throw new Error(`Nyte has no native release for ${process.platform}/${process.arch}.`);
+  }
+  const root = options.root ?? cacheRoot(options.env);
+  const binary = join(root, version, "nyte");
+  if ((await stat(binary).catch(() => undefined))?.isFile()) return binary;
+
+  const fetchFn = options.fetchFn ?? globalThis.fetch;
+  const asset = releaseAssetName(version, target);
+  const base = `https://github.com/${REPOSITORY}/releases/download/v${version}`;
+  const versionDir = dirname(binary);
+  const archive = join(versionDir, `${asset}.tar.gz`);
+  await mkdir(versionDir, { recursive: true });
+  try {
+    const checksum = (await (await fetchOk(fetchFn, `${base}/${asset}.tar.gz.sha256`)).text())
+      .trim()
+      .split(/\s+/u)[0]
+      ?.toLowerCase();
+    if (checksum === undefined || !/^[0-9a-f]{64}$/u.test(checksum)) {
+      throw new Error(`The checksum file for ${asset} is malformed.`);
+    }
+    await download(fetchFn, `${base}/${asset}.tar.gz`, archive);
+    const actual = await sha256(archive);
+    if (actual !== checksum) {
+      throw new Error(`Checksum mismatch for ${asset}: expected ${checksum}, got ${actual}.`);
+    }
+    const result = spawn("tar", ["-xzf", archive, "-C", versionDir], { stdio: "inherit" });
+    const exitCode = await new Promise((resolve, reject) => {
+      result.once("error", reject);
+      result.once("exit", (code, signal) => {
+        if (signal !== null) reject(new Error(`tar exited from signal ${signal}.`));
+        else resolve(code);
+      });
+    });
+    if (exitCode !== 0 || !(await stat(binary).catch(() => undefined))?.isFile()) {
+      throw new Error(`${asset}.tar.gz does not contain a nyte binary.`);
+    }
+    await chmod(binary, 0o755);
+    return binary;
+  } catch (error) {
+    await rm(binary, { force: true });
+    throw error;
+  } finally {
+    await rm(archive, { force: true });
+  }
+}
+
+export async function launch(args = process.argv.slice(2), options = {}) {
+  const binary = await ensureBinary(options);
+  const child = spawn(binary, args, { stdio: "inherit" });
+  const forwardInt = () => {
+    if (!child.killed) child.kill("SIGINT");
+  };
+  const forwardTerm = () => {
+    if (!child.killed) child.kill("SIGTERM");
+  };
+  process.once("SIGINT", forwardInt);
+  process.once("SIGTERM", forwardTerm);
+  return new Promise((resolve, reject) => {
+    child.once("error", reject);
+    child.once("exit", (code, signal) => {
+      process.removeListener("SIGINT", forwardInt);
+      process.removeListener("SIGTERM", forwardTerm);
+      if (signal !== null) {
+        process.kill(process.pid, signal);
+        return;
+      }
+      resolve(code ?? 1);
+    });
+  });
+}