@iletai/nzb 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Burke Holland
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,132 @@
+# NZB
+
+AI orchestrator powered by [Copilot SDK](https://github.com/github/copilot-sdk) — control multiple Copilot CLI sessions from Telegram or a local terminal.
+
+## Install
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/iletai/AI-Agent-Assistant/main/install.sh | bash
+```
+
+Or install directly with npm:
+
+```bash
+npm install -g nzb
+```
+
+## Quick Start
+
+### 1. Run setup
+
+```bash
+nzb setup
+```
+
+This creates `~/.nzb/` and walks you through configuration (Telegram bot token, etc.). Telegram is optional — you can use NZB with just the terminal UI.
+
+### 2. Make sure Copilot CLI is authenticated
+
+```bash
+copilot login
+```
+
+### 3. Start NZB
+
+```bash
+nzb start
+```
+
+### 4. Connect via terminal
+
+In a separate terminal:
+
+```bash
+nzb tui
+```
+
+### 5. Talk to NZB
+
+From Telegram or the TUI, just send natural language:
+
+- "Start working on the auth bug in ~/dev/myapp"
+- "What sessions are running?"
+- "Check on the api-tests session"
+- "Kill the auth-fix session"
+- "What's the capital of France?"
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `nzb start` | Start the NZB daemon |
+| `nzb tui` | Connect to the daemon via terminal |
+| `nzb setup` | Interactive first-run configuration |
+| `nzb update` | Check for and install updates |
+| `nzb help` | Show available commands |
+
+### Flags
+
+| Flag | Description |
+|------|-------------|
+| `--self-edit` | Allow NZB to modify his own source code (use with `nzb start`) |
+
+### TUI commands
+
+| Command | Description |
+|---------|-------------|
+| `/model [name]` | Show or switch the current model |
+| `/memory` | Show stored memories |
+| `/skills` | List installed skills |
+| `/workers` | List active worker sessions |
+| `/copy` | Copy last response to clipboard |
+| `/status` | Daemon health check |
+| `/restart` | Restart the daemon |
+| `/cancel` | Cancel the current in-flight message |
+| `/clear` | Clear the screen |
+| `/help` | Show help |
+| `/quit` | Exit the TUI |
+| `Escape` | Cancel a running response |
+
+## How it Works
+
+NZB runs a persistent **orchestrator Copilot session** — an always-on AI brain that receives your messages and decides how to handle them. For coding tasks, it spawns **worker Copilot sessions** in specific directories. For simple questions, it answers directly.
+
+You can talk to NZB from:
+
+- **Telegram** — remote access from your phone (authenticated by user ID)
+- **TUI** — local terminal client (no auth needed)
+
+## Architecture
+
+```
+Telegram ──→ NZB Daemon ←── TUI
+                │
+          Orchestrator Session (Copilot SDK)
+                │
+      ┌─────────┼─────────┐
+   Worker 1  Worker 2  Worker N
+```
+
+- **Daemon** (`nzb start`) — persistent service running Copilot SDK + Telegram bot + HTTP API
+- **TUI** (`nzb tui`) — lightweight terminal client connecting to the daemon
+- **Orchestrator** — long-running Copilot session with custom tools for session management
+- **Workers** — child Copilot sessions for specific coding tasks
+
+## Development
+
+```bash
+# Clone and install
+git clone https://github.com/iletai/AI-Agent-Assistant.git
+cd AI-Agent-Assistant
+npm install
+
+# Watch mode
+npm run dev
+
+# Build TypeScript
+npm run build
+```
+
+This project uses TypeScript, Zod for schema validation, and a simple file-based SQLite database for state management. The Copilot SDK is used to create and manage AI sessions, and the Telegram Bot API is used for remote messaging. Reference the source code for implementation details!
+
+Thankful for <https://github.com/burkeholland/max> which inspired this project.

package/dist/api/server.js

@@ -0,0 +1,212 @@
+import { randomBytes } from "crypto";
+import express from "express";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { config, persistModel } from "../config.js";
+import { cancelCurrentMessage, getWorkers, sendToOrchestrator } from "../copilot/orchestrator.js";
+import { listSkills, removeSkill } from "../copilot/skills.js";
+import { restartDaemon } from "../daemon.js";
+import { API_TOKEN_PATH, ensureNZBHome } from "../paths.js";
+import { searchMemories } from "../store/db.js";
+import { sendPhoto } from "../telegram/bot.js";
+// Ensure token file exists (generate on first run)
+let apiToken = null;
+try {
+    if (existsSync(API_TOKEN_PATH)) {
+        apiToken = readFileSync(API_TOKEN_PATH, "utf-8").trim();
+    }
+    else {
+        ensureNZBHome();
+        apiToken = randomBytes(32).toString("hex");
+        writeFileSync(API_TOKEN_PATH, apiToken, { mode: 0o600 });
+    }
+}
+catch (err) {
+    console.error(`[auth] Failed to load/generate API token: ${err}`);
+    process.exit(1);
+}
+const app = express();
+app.use(express.json());
+// Bearer token authentication middleware (skip /status health check)
+app.use((req, res, next) => {
+    if (!apiToken || req.path === "/status" || req.path === "/send-photo")
+        return next();
+    const auth = req.headers.authorization;
+    if (!auth || auth !== `Bearer ${apiToken}`) {
+        res.status(401).json({ error: "Unauthorized" });
+        return;
+    }
+    next();
+});
+// Active SSE connections
+const sseClients = new Map();
+let connectionCounter = 0;
+// Health check
+app.get("/status", (_req, res) => {
+    res.json({
+        status: "ok",
+        workers: Array.from(getWorkers().values()).map((w) => ({
+            name: w.name,
+            workingDir: w.workingDir,
+            status: w.status,
+        })),
+    });
+});
+// List worker sessions
+app.get("/sessions", (_req, res) => {
+    const workers = Array.from(getWorkers().values()).map((w) => ({
+        name: w.name,
+        workingDir: w.workingDir,
+        status: w.status,
+        lastOutput: w.lastOutput?.slice(0, 500),
+    }));
+    res.json(workers);
+});
+// SSE stream for real-time responses
+app.get("/stream", (req, res) => {
+    const connectionId = `tui-${++connectionCounter}`;
+    res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+    });
+    res.write(`data: ${JSON.stringify({ type: "connected", connectionId })}\n\n`);
+    sseClients.set(connectionId, res);
+    // Heartbeat to keep connection alive
+    const heartbeat = setInterval(() => {
+        res.write(`:ping\n\n`);
+    }, 20_000);
+    req.on("close", () => {
+        clearInterval(heartbeat);
+        sseClients.delete(connectionId);
+    });
+});
+// Send a message to the orchestrator
+app.post("/message", (req, res) => {
+    const { prompt, connectionId } = req.body;
+    if (!prompt || typeof prompt !== "string") {
+        res.status(400).json({ error: "Missing 'prompt' in request body" });
+        return;
+    }
+    if (!connectionId || !sseClients.has(connectionId)) {
+        res.status(400).json({ error: "Missing or invalid 'connectionId'. Connect to /stream first." });
+        return;
+    }
+    sendToOrchestrator(prompt, { type: "tui", connectionId }, (text, done) => {
+        const sseRes = sseClients.get(connectionId);
+        if (sseRes) {
+            sseRes.write(`data: ${JSON.stringify({ type: done ? "message" : "delta", content: text })}\n\n`);
+        }
+    });
+    res.json({ status: "queued" });
+});
+// Cancel the current in-flight message
+app.post("/cancel", async (_req, res) => {
+    const cancelled = await cancelCurrentMessage();
+    // Notify all SSE clients that the message was cancelled
+    for (const [, sseRes] of sseClients) {
+        sseRes.write(`data: ${JSON.stringify({ type: "cancelled" })}\n\n`);
+    }
+    res.json({ status: "ok", cancelled });
+});
+// Get or switch model
+app.get("/model", (_req, res) => {
+    res.json({ model: config.copilotModel });
+});
+app.post("/model", async (req, res) => {
+    const { model } = req.body;
+    if (!model || typeof model !== "string") {
+        res.status(400).json({ error: "Missing 'model' in request body" });
+        return;
+    }
+    // Validate against available models before persisting
+    try {
+        const { getClient } = await import("../copilot/client.js");
+        const client = await getClient();
+        const models = await client.listModels();
+        const match = models.find((m) => m.id === model);
+        if (!match) {
+            const suggestions = models
+                .filter((m) => m.id.includes(model) || m.id.toLowerCase().includes(model.toLowerCase()))
+                .map((m) => m.id);
+            const hint = suggestions.length > 0 ? ` Did you mean: ${suggestions.join(", ")}?` : "";
+            res.status(400).json({ error: `Model '${model}' not found.${hint}` });
+            return;
+        }
+    }
+    catch {
+        // If we can't validate (client not ready), allow the switch — it'll fail on next message if wrong
+    }
+    const previous = config.copilotModel;
+    config.copilotModel = model;
+    persistModel(model);
+    res.json({ previous, current: model });
+});
+// List memories
+app.get("/memory", (_req, res) => {
+    const memories = searchMemories(undefined, undefined, 100);
+    res.json(memories);
+});
+// List skills
+app.get("/skills", (_req, res) => {
+    const skills = listSkills();
+    res.json(skills);
+});
+// Remove a local skill
+app.delete("/skills/:slug", (req, res) => {
+    const slug = Array.isArray(req.params.slug) ? req.params.slug[0] : req.params.slug;
+    const result = removeSkill(slug);
+    if (!result.ok) {
+        res.status(400).json({ error: result.message });
+    }
+    else {
+        res.json({ ok: true, message: result.message });
+    }
+});
+// Restart daemon
+app.post("/restart", (_req, res) => {
+    res.json({ status: "restarting" });
+    setTimeout(() => {
+        restartDaemon().catch((err) => {
+            console.error("[nzb] Restart failed:", err);
+        });
+    }, 500);
+});
+// Send a photo to Telegram (protected by bearer token auth middleware)
+app.post("/send-photo", async (req, res) => {
+    const { photo, caption } = req.body;
+    if (!photo || typeof photo !== "string") {
+        res.status(400).json({ error: "Missing 'photo' (file path or URL) in request body" });
+        return;
+    }
+    try {
+        await sendPhoto(photo, caption);
+        res.json({ status: "sent" });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        res.status(500).json({ error: msg });
+    }
+});
+export function startApiServer() {
+    return new Promise((resolve, reject) => {
+        const server = app.listen(config.apiPort, "127.0.0.1", () => {
+            console.log(`[nzb] HTTP API listening on http://127.0.0.1:${config.apiPort}`);
+            resolve();
+        });
+        server.on("error", (err) => {
+            if (err.code === "EADDRINUSE") {
+                reject(new Error(`Port ${config.apiPort} is already in use. Is another NZB instance running?`));
+            }
+            else {
+                reject(err);
+            }
+        });
+    });
+}
+/** Broadcast a proactive message to all connected SSE clients (for background task completions). */
+export function broadcastToSSE(text) {
+    for (const [, res] of sseClients) {
+        res.write(`data: ${JSON.stringify({ type: "message", content: text })}\n\n`);
+    }
+}
+//# sourceMappingURL=server.js.map

package/dist/cli.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+function getVersion() {
+    try {
+        const pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));
+        return pkg.version || "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+function printHelp() {
+    const version = getVersion();
+    console.log(`
+nzb v${version} — AI orchestrator powered by Copilot SDK
+
+Usage:
+  nzb <command>
+
+Commands:
+  start       Start the NZB daemon (Telegram bot + HTTP API)
+  tui         Connect to the daemon via terminal UI
+  setup       Interactive first-run configuration
+  update      Check for updates and install the latest version
+  help        Show this help message
+
+Flags (start):
+  --self-edit Allow NZB to modify his own source code (off by default)
+
+Examples:
+  nzb start           Start the daemon
+  nzb start --self-edit  Start with self-edit enabled
+  nzb tui             Open the terminal client
+  nzb setup           Configure Telegram token and settings
+`.trim());
+}
+const args = process.argv.slice(2);
+const command = args[0] || "help";
+switch (command) {
+    case "start": {
+        // Parse flags for start command
+        const startFlags = args.slice(1);
+        if (startFlags.includes("--self-edit")) {
+            process.env.NZB_SELF_EDIT = "1";
+        }
+        await import("./daemon.js");
+        break;
+    }
+    case "tui":
+        await import("./tui/index.js");
+        break;
+    case "setup":
+        await import("./setup.js");
+        break;
+    case "update": {
+        const { checkForUpdate, performUpdate } = await import("./update.js");
+        const check = await checkForUpdate();
+        if (!check.checkSucceeded) {
+            console.error("Warning: Could not reach the npm registry. Check your network and try again.");
+            process.exit(1);
+        }
+        if (!check.updateAvailable) {
+            console.log(`nzb v${check.current} is already the latest version.`);
+            break;
+        }
+        console.log(`Update available: v${check.current} → v${check.latest}`);
+        console.log("Installing...");
+        const result = await performUpdate();
+        if (result.ok) {
+            console.log(`Updated to v${check.latest}`);
+        }
+        else {
+            console.error(`Update failed: ${result.output}`);
+            process.exit(1);
+        }
+        break;
+    }
+    case "help":
+    case "--help":
+    case "-h":
+        printHelp();
+        break;
+    case "--version":
+    case "-v":
+        console.log(getVersion());
+        break;
+    default:
+        console.error(`Unknown command: ${command}\n`);
+        printHelp();
+        process.exit(1);
+}
+//# sourceMappingURL=cli.js.map

package/dist/config.js

@@ -0,0 +1,72 @@
+import { config as loadEnv } from "dotenv";
+import { readFileSync, writeFileSync } from "fs";
+import { z } from "zod";
+import { ENV_PATH, ensureNZBHome } from "./paths.js";
+// Load from ~/.nzb/.env, fall back to cwd .env for dev
+loadEnv({ path: ENV_PATH });
+loadEnv(); // also check cwd for backwards compat
+const configSchema = z.object({
+    TELEGRAM_BOT_TOKEN: z.string().min(1).optional(),
+    AUTHORIZED_USER_ID: z.string().min(1).optional(),
+    API_PORT: z.string().optional(),
+    COPILOT_MODEL: z.string().optional(),
+    WORKER_TIMEOUT: z.string().optional(),
+});
+const raw = configSchema.parse(process.env);
+const parsedUserId = raw.AUTHORIZED_USER_ID ? parseInt(raw.AUTHORIZED_USER_ID, 10) : undefined;
+const parsedPort = parseInt(raw.API_PORT || "7777", 10);
+if (parsedUserId !== undefined && (Number.isNaN(parsedUserId) || parsedUserId <= 0)) {
+    throw new Error(`AUTHORIZED_USER_ID must be a positive integer, got: "${raw.AUTHORIZED_USER_ID}"`);
+}
+if (Number.isNaN(parsedPort) || parsedPort < 1 || parsedPort > 65535) {
+    throw new Error(`API_PORT must be 1-65535, got: "${raw.API_PORT}"`);
+}
+const DEFAULT_WORKER_TIMEOUT_MS = 600_000; // 10 minutes
+const parsedWorkerTimeout = raw.WORKER_TIMEOUT ? Number(raw.WORKER_TIMEOUT) : DEFAULT_WORKER_TIMEOUT_MS;
+if (!Number.isInteger(parsedWorkerTimeout) || parsedWorkerTimeout <= 0) {
+    throw new Error(`WORKER_TIMEOUT must be a positive integer (ms), got: "${raw.WORKER_TIMEOUT}"`);
+}
+export const DEFAULT_MODEL = "claude-sonnet-4.6";
+let _copilotModel = raw.COPILOT_MODEL || DEFAULT_MODEL;
+export const config = {
+    telegramBotToken: raw.TELEGRAM_BOT_TOKEN,
+    authorizedUserId: parsedUserId,
+    apiPort: parsedPort,
+    workerTimeoutMs: parsedWorkerTimeout,
+    get copilotModel() {
+        return _copilotModel;
+    },
+    set copilotModel(model) {
+        _copilotModel = model;
+    },
+    get telegramEnabled() {
+        return !!this.telegramBotToken && this.authorizedUserId !== undefined;
+    },
+    get selfEditEnabled() {
+        return process.env.NZB_SELF_EDIT === "1";
+    },
+};
+/** Persist the current model choice to ~/.nzb/.env */
+export function persistModel(model) {
+    ensureNZBHome();
+    try {
+        const content = readFileSync(ENV_PATH, "utf-8");
+        const lines = content.split("\n");
+        let found = false;
+        const updated = lines.map((line) => {
+            if (line.startsWith("COPILOT_MODEL=")) {
+                found = true;
+                return `COPILOT_MODEL=${model}`;
+            }
+            return line;
+        });
+        if (!found)
+            updated.push(`COPILOT_MODEL=${model}`);
+        writeFileSync(ENV_PATH, updated.join("\n"));
+    }
+    catch {
+        // File doesn't exist — create it
+        writeFileSync(ENV_PATH, `COPILOT_MODEL=${model}\n`);
+    }
+}
+//# sourceMappingURL=config.js.map

package/dist/copilot/client.js

@@ -0,0 +1,32 @@
+import { CopilotClient } from "@github/copilot-sdk";
+let client;
+export async function getClient() {
+    if (!client) {
+        client = new CopilotClient({
+            autoStart: true,
+            autoRestart: true,
+        });
+        await client.start();
+    }
+    return client;
+}
+/** Tear down the existing client and create a fresh one. */
+export async function resetClient() {
+    if (client) {
+        try {
+            await client.stop();
+        }
+        catch {
+            /* best-effort */
+        }
+        client = undefined;
+    }
+    return getClient();
+}
+export async function stopClient() {
+    if (client) {
+        await client.stop();
+        client = undefined;
+    }
+}
+//# sourceMappingURL=client.js.map

package/dist/copilot/mcp-config.js

@@ -0,0 +1,22 @@
+import { readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+/**
+ * Load MCP server configs from ~/.copilot/mcp-config.json.
+ * Returns an empty record if the file doesn't exist or is invalid.
+ */
+export function loadMcpConfig() {
+    const configPath = join(homedir(), ".copilot", "mcp-config.json");
+    try {
+        const raw = readFileSync(configPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed.mcpServers && typeof parsed.mcpServers === "object") {
+            return parsed.mcpServers;
+        }
+        return {};
+    }
+    catch {
+        return {};
+    }
+}
+//# sourceMappingURL=mcp-config.js.map