@higherdev/cli 0.4.0 → 0.6.0

package/README.md

@@ -14,19 +14,24 @@ Create `~/.config/hd/config.json` with an existing workspace API key:
 {
   "url": "https://hdx-higher-ops.vercel.app",
   "api_key": "hdx_...",
-  "slug": "workspace"
+  "current": "workspace"
 }
 ```
 
+One workspace key reaches every workspace. Previous single-workspace and
+workspace-map config shapes are migrated automatically when they are read.
+
 ## Commands
 
 | Command | Purpose |
 | --- | --- |
-| `hd` | Show the HigherDEV banner and usage |
+| `hd` | Open the live TUI when attached to a terminal |
+| `hd --help` | Show the HigherDEV banner and usage |
 | `hd status` | Show workspace, ticket, run, and decision status |
 | `hd ticket list` | List tickets |
 | `hd ticket show KEY` | Show one ticket |
 | `hd ticket new --title TITLE [options]` | Create a ticket |
+| `hd workspace ls` | List every workspace available to the configured key |
 | `hd workspace new --name NAME --repo OWNER/NAME [options]` | Create a paused workspace |
 | `hd agents` | List agents |
 | `hd agents set ROLE --provider P --model M [--effort E]` | Update an agent |
@@ -39,4 +44,6 @@ Create `~/.config/hd/config.json` with an existing workspace API key:
 | `hd init [options]` | Configure this host and runner service |
 | `hd upgrade [options]` | Refresh this host configuration |
 
-Run `hd` for the compact command summary.
+Inside the TUI, use `/board`, `/inbox`, `/ticket`, `/decide`, `/agents`,
+`/settings`, `/workspace`, `/feed`, `/orchestrator`, `/refresh`, `/help`, or
+`/exit`. The display refreshes from the HDX API every five seconds.

package/dist/api.js

@@ -1,4 +1,19 @@
 import { loadConfig } from "./config.js";
+export const MAX_API_ERROR_BODY = 500;
+export function apiErrorMessage(status, parsed, fallback) {
+    const raw = parsed && typeof parsed === "object" && "error" in parsed
+        && typeof parsed.error === "string"
+        ? parsed.error : fallback;
+    const duplicate = raw.match(/agents_one_enabled_(orchestrator|reviewer)_idx/i)?.[1]?.toLowerCase();
+    if (duplicate) {
+        return `hd: ${status} Only one enabled ${duplicate} is allowed per workspace. Disable the current ${duplicate} before enabling another.`;
+    }
+    const trimmed = raw.trim();
+    const body = trimmed.length > MAX_API_ERROR_BODY
+        ? `${trimmed.slice(0, MAX_API_ERROR_BODY)}... [truncated ${trimmed.length - MAX_API_ERROR_BODY} chars]`
+        : trimmed;
+    return `hd: ${status} ${body}`;
+}
 async function request(config, method, path, body) {
     const response = await fetch(`${config.url}${path}`, {
         method,
@@ -14,32 +29,26 @@ async function request(config, method, path, body) {
         parsed = text ? JSON.parse(text) : null;
     }
     catch {
-        throw new Error(`hd: ${response.status} ${text || response.statusText}`);
+        throw new Error(apiErrorMessage(response.status, null, text || response.statusText));
     }
     if (!response.ok) {
-        const err = parsed;
-        throw new Error(`hd: ${response.status} ${err.error ?? text}`);
+        throw new Error(apiErrorMessage(response.status, parsed, text || response.statusText));
     }
     return parsed;
 }
-export async function getStatus() {
-    const config = loadConfig();
+export async function getStatus(config = loadConfig()) {
     return request(config, "GET", `/api/w/${config.slug}/status`);
 }
-export async function listTickets() {
-    const config = loadConfig();
+export async function listTickets(config = loadConfig()) {
     return request(config, "GET", `/api/w/${config.slug}/tickets`);
 }
-export async function showTicket(key) {
-    const config = loadConfig();
+export async function showTicket(key, config = loadConfig()) {
     return request(config, "GET", `/api/w/${config.slug}/tickets/${encodeURIComponent(key)}`);
 }
-export async function createTicket(fields) {
-    const config = loadConfig();
+export async function createTicket(fields, config = loadConfig()) {
     return request(config, "POST", `/api/w/${config.slug}/tickets`, fields);
 }
-export async function listTicketEvents(key, afterAt, afterId) {
-    const config = loadConfig();
+export async function listTicketEvents(key, afterAt, afterId, config = loadConfig()) {
     const query = new URLSearchParams();
     if (afterAt)
         query.set("after_at", afterAt);
@@ -48,29 +57,46 @@ export async function listTicketEvents(key, afterAt, afterId) {
     const suffix = query.size ? `?${query.toString()}` : "";
     return request(config, "GET", `/api/w/${config.slug}/tickets/${encodeURIComponent(key)}/events${suffix}`);
 }
-export async function postMessage(fields) {
-    const config = loadConfig();
+export async function postMessage(fields, config = loadConfig()) {
     return request(config, "POST", `/api/w/${config.slug}/messages`, fields);
 }
-export async function answerDecision(id, answer_md) {
-    const config = loadConfig();
+export async function answerDecision(id, answer_md, config = loadConfig()) {
     return request(config, "POST", `/api/w/${config.slug}/decisions/${encodeURIComponent(id)}/answer`, { answer_md });
 }
-export async function setPaused(paused) {
-    const config = loadConfig();
+export async function setPaused(paused, config = loadConfig()) {
     const path = paused ? `/api/w/${config.slug}/pause` : `/api/w/${config.slug}/resume`;
     return request(config, "POST", path);
 }
-export async function createWorkspace(fields) {
-    const config = loadConfig();
+export async function createWorkspace(fields, config = loadConfig()) {
     const result = await request(config, "POST", "/api/workspaces", fields);
     return { ...result, url: config.url };
 }
-export async function listAgents() {
-    const config = loadConfig();
+export async function listWorkspaces(config = loadConfig()) {
+    return request(config, "GET", "/api/workspaces");
+}
+export async function listAgents(config = loadConfig()) {
     return request(config, "GET", `/api/w/${config.slug}/agents`);
 }
-export async function updateAgent(id, fields) {
-    const config = loadConfig();
+export async function updateAgent(id, fields, config = loadConfig()) {
     return request(config, "PATCH", `/api/w/${config.slug}/agents`, { id, ...fields });
 }
+export async function listEpics(config = loadConfig()) {
+    return request(config, "GET", `/api/w/${config.slug}/epics`);
+}
+export async function listMessages(options = {}, config = loadConfig()) {
+    const query = new URLSearchParams();
+    if (options.ticketId)
+        query.set("ticket_id", options.ticketId);
+    if (options.since)
+        query.set("since", options.since);
+    if (options.limit)
+        query.set("limit", String(options.limit));
+    const suffix = query.size ? `?${query.toString()}` : "";
+    return request(config, "GET", `/api/w/${config.slug}/messages${suffix}`);
+}
+export async function updateCaps(provider_caps, config = loadConfig()) {
+    return request(config, "PATCH", `/api/w/${config.slug}/caps`, { provider_caps });
+}
+export async function listFeed(config = loadConfig()) {
+    return request(config, "GET", `/api/w/${config.slug}/feed`);
+}

package/dist/config.js

@@ -4,23 +4,72 @@ import { chmodSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 export function configPath() {
     return process.env.HD_CONFIG ?? join(homedir(), ".config/hd/config.json");
 }
-export function loadConfig() {
-    const path = configPath();
+function normalizeConnection(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const row = value;
+    if (typeof row.url !== "string" || typeof row.api_key !== "string" || !row.url || !row.api_key) {
+        return null;
+    }
+    return { url: row.url.replace(/\/$/, ""), api_key: row.api_key };
+}
+function missing(path) {
+    return new Error(`missing ${path}\nWrite { "url": "https://hdx-higher-ops.vercel.app", "api_key": "hdx_...", "current": "workspace" }`);
+}
+export function loadStoredConfig(path = configPath()) {
     let raw;
     try {
         raw = readFileSync(path, "utf8");
     }
     catch {
-        throw new Error(`missing ${path}\nWrite { "url": "https://hdx-higher-ops.vercel.app", "api_key": "hdx_...", "slug": "workspace" }`);
+        throw missing(path);
     }
     const parsed = JSON.parse(raw);
-    if (!parsed.url || !parsed.api_key || !parsed.slug) {
-        throw new Error(`${path} needs url, api_key, and slug`);
+    const connection = normalizeConnection(parsed);
+    const current = typeof parsed.current === "string" ? parsed.current : "";
+    if (connection && current)
+        return { ...connection, current };
+    // 0.4 stored one workspace at the top level with `slug` rather than
+    // `current`. One key can now reach every workspace, so only the selected
+    // slug needs to survive.
+    if (connection && typeof parsed.slug === "string" && parsed.slug) {
+        const migrated = { ...connection, current: parsed.slug };
+        writeStoredConfig(migrated, path);
+        return migrated;
     }
-    return { url: parsed.url.replace(/\/$/, ""), api_key: parsed.api_key, slug: parsed.slug };
+    // 0.5 stored one connection per workspace. Keep the current workspace's
+    // credentials as the shared operator connection and discard the duplicates.
+    const source = parsed.workspaces;
+    if (!current || !source || typeof source !== "object" || Array.isArray(source)) {
+        throw new Error(`${path} needs url, api_key, and current`);
+    }
+    const selected = normalizeConnection(source[current]);
+    if (!selected)
+        throw new Error(`${path} current workspace ${current} is not configured`);
+    const migrated = { ...selected, current };
+    writeStoredConfig(migrated, path);
+    return migrated;
 }
-export function writeHdConfig(config, path = configPath()) {
+export function loadConfig(slug) {
+    const stored = loadStoredConfig();
+    const selected = slug ?? stored.current;
+    return { url: stored.url, api_key: stored.api_key, slug: selected };
+}
+export function writeStoredConfig(config, path = configPath()) {
     mkdirSync(dirname(path), { recursive: true });
     writeFileSync(path, `${JSON.stringify(config, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
     chmodSync(path, 0o600);
 }
+/** Store one operator connection and make its selected workspace current. */
+export function writeHdConfig(config, path = configPath()) {
+    writeStoredConfig({
+        url: config.url.replace(/\/$/, ""),
+        api_key: config.api_key,
+        current: config.slug,
+    }, path);
+}
+export function switchWorkspace(slug, path = configPath()) {
+    const stored = loadStoredConfig(path);
+    writeStoredConfig({ ...stored, current: slug }, path);
+    return { url: stored.url, api_key: stored.api_key, slug };
+}

package/dist/index.js

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 import { realpathSync } from "node:fs";
 import { pathToFileURL } from "node:url";
-import { answerDecision, createTicket, createWorkspace, getStatus, listAgents, listTicketEvents, listTickets, postMessage, setPaused, showTicket, updateAgent, } from "./api.js";
+import { answerDecision, createTicket, createWorkspace, getStatus, listAgents, listTicketEvents, listTickets, listWorkspaces, postMessage, setPaused, showTicket, updateAgent, } from "./api.js";
 import { initHost, parseHostFlags } from "./host.js";
+import { loadConfig, writeHdConfig } from "./config.js";
 import { banner, c, statusChip, table, truncate, usage } from "./out.js";
 function fail(message) {
     console.error(message);
@@ -175,8 +176,20 @@ async function cmdDecide(argv) {
 }
 async function cmdWorkspace(argv) {
     const [action, ...rest] = argv;
+    if (action === "ls") {
+        const current = loadConfig().slug;
+        const workspaces = await listWorkspaces();
+        console.log(table(["", "SLUG", "NAME", "REPO", "STATE"], workspaces.map((workspace) => [
+            workspace.slug === current ? "*" : "",
+            workspace.slug,
+            workspace.name,
+            workspace.repo,
+            workspace.on ? c.green("on") : c.dim("off"),
+        ])));
+        return;
+    }
     if (action !== "new")
-        fail("usage: hd workspace new --name NAME --repo OWNER/NAME [--slug S] [--branch main] [--host box]");
+        fail("usage: hd workspace ls | new --name NAME --repo OWNER/NAME [--slug S] [--branch main] [--host box]");
     const { opts } = flags(rest);
     if (!opts.name || !opts.repo) {
         fail("usage: hd workspace new --name NAME --repo OWNER/NAME [--slug S] [--branch main] [--host box]");
@@ -184,7 +197,8 @@ async function cmdWorkspace(argv) {
     const result = await createWorkspace({ name: opts.name, repo: opts.repo, slug: opts.slug,
         default_branch: opts.branch ?? "main", default_host: opts.host ?? "box" });
     console.log(`workspace: ${result.workspace.slug}`);
-    console.log("api key shown once; switch with:");
+    writeHdConfig({ url: result.url, api_key: result.api_key, slug: result.workspace.slug });
+    console.log("saved and switched; configure another machine with:");
     console.log(`hd init --url ${result.url} --api-key ${result.api_key} --slug ${result.workspace.slug}`);
 }
 function selectAgent(agents, role, provider) {
@@ -225,6 +239,18 @@ export async function main(argv = process.argv.slice(2)) {
     const [cmd, ...rest] = argv;
     try {
         if (!cmd) {
+            const { canLaunchApp } = await import("./tui/capability.js");
+            if (canLaunchApp()) {
+                const { launchApp } = await import("./tui/launch.js");
+                await launchApp();
+                return;
+            }
+            console.log(banner());
+            console.log("");
+            console.log(usage());
+            return;
+        }
+        if (cmd === "--help" || cmd === "-h") {
             console.log(banner());
             console.log("");
             console.log(usage());

package/dist/out/format.js

@@ -0,0 +1,96 @@
+import { statusTone } from "../tui/data.js";
+import { c, DOT, ELLIPSIS, tone } from "./theme.js";
+export function truncate(text, max) {
+    const flat = String(text ?? "")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (flat.length <= max)
+        return flat;
+    return `${flat.slice(0, Math.max(0, max - 1))}${ELLIPSIS}`;
+}
+const ANSI = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
+export function displayWidth(text) {
+    return text.replace(ANSI, "").length;
+}
+export function pad(text, width) {
+    const gap = width - displayWidth(text);
+    return gap > 0 ? text + " ".repeat(gap) : text;
+}
+export function padStart(text, width) {
+    const gap = width - displayWidth(text);
+    return gap > 0 ? " ".repeat(gap) + text : text;
+}
+/** Fixed-width table. Widths measure printable characters, not escape codes. */
+export function table(columns, rows) {
+    if (rows.length === 0)
+        return c.dim("none");
+    const widths = columns.map((column, i) => Math.max(displayWidth(column.header), ...rows.map((row) => displayWidth(row[i] ?? ""))));
+    const line = (cells) => cells
+        .map((cell, i) => {
+        if (i === cells.length - 1 && columns[i]?.align !== "right")
+            return cell;
+        return columns[i]?.align === "right" ? padStart(cell, widths[i]) : pad(cell, widths[i]);
+    })
+        .join("  ")
+        .trimEnd();
+    return [c.dim(line(columns.map((column) => column.header))), ...rows.map(line)].join("\n");
+}
+export function statusChip(status) {
+    return tone(statusTone(status), status.replaceAll("_", " "));
+}
+export function stateDot(state) {
+    return tone(state, DOT);
+}
+export function relativeTime(iso, now = Date.now()) {
+    if (!iso)
+        return "never";
+    const at = Date.parse(iso);
+    if (Number.isNaN(at))
+        return "never";
+    const seconds = Math.round((now - at) / 1000);
+    if (seconds < 0)
+        return "just now";
+    if (seconds < 60)
+        return `${seconds}s ago`;
+    const minutes = Math.round(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.round(minutes / 60);
+    if (hours < 48)
+        return `${hours}h ago`;
+    return `${Math.round(hours / 24)}d ago`;
+}
+export function elapsed(from, to, now = Date.now()) {
+    if (!from)
+        return "";
+    const start = Date.parse(from);
+    if (Number.isNaN(start))
+        return "";
+    const parsedEnd = to ? Date.parse(to) : now;
+    const end = Number.isNaN(parsedEnd) ? now : parsedEnd;
+    const seconds = Math.max(0, Math.round((end - start) / 1000));
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m${seconds % 60 ? ` ${seconds % 60}s` : ""}`;
+    const hours = Math.floor(minutes / 60);
+    return `${hours}h${minutes % 60 ? ` ${minutes % 60}m` : ""}`;
+}
+export function heading(text) {
+    return c.bold(text);
+}
+export function bullet(text) {
+    return `${c.dim("-")} ${text}`;
+}
+export function section(title, body) {
+    return `${heading(title)}\n${body}`;
+}
+/** A one-line horizontal bar for spend and progress. */
+export function bar(value, max, width = 20) {
+    if (!(max > 0))
+        return c.dim("-".repeat(width));
+    const filled = Math.max(0, Math.min(width, Math.round((value / max) * width)));
+    return c.blue("█".repeat(filled)) + c.dim("░".repeat(width - filled));
+}
+export { DOT };

package/dist/out/theme.js

@@ -0,0 +1,73 @@
+/**
+ * Terminal palette. The web app is light only by decision; a terminal is the
+ * user's own surface, so nothing here paints a background. Foreground and dim
+ * only, blue as the single accent, status colour confined to state.
+ */
+const ESC = `${String.fromCharCode(27)}[`;
+export function colorEnabled(stream = process.stdout) {
+    if (process.env.HIGHERDEV_FORCE_COLOR === "1")
+        return true;
+    if (process.env.NO_COLOR)
+        return false;
+    return Boolean(stream.isTTY);
+}
+const CODES = {
+    bold: 1,
+    dim: 2,
+    red: 31,
+    green: 32,
+    yellow: 33,
+    magenta: 35,
+    cyan: 36,
+    grey: 90,
+    blue: 94,
+};
+function wrap(name, text) {
+    if (!colorEnabled())
+        return text;
+    return `${ESC}${CODES[name]}m${text}${ESC}0m`;
+}
+export const c = {
+    bold: (t) => wrap("bold", t),
+    dim: (t) => wrap("dim", t),
+    blue: (t) => wrap("blue", t),
+    green: (t) => wrap("green", t),
+    yellow: (t) => wrap("yellow", t),
+    red: (t) => wrap("red", t),
+    grey: (t) => wrap("grey", t),
+    cyan: (t) => wrap("cyan", t),
+    magenta: (t) => wrap("magenta", t),
+};
+export function tone(value, text) {
+    switch (value) {
+        case "blue":
+            return c.blue(text);
+        case "success":
+            return c.green(text);
+        case "warning":
+            return c.yellow(text);
+        case "danger":
+            return c.red(text);
+        default:
+            return c.dim(text);
+    }
+}
+/** Ink colour name for the same tone, so plain and TUI output agree. */
+export function inkColor(value) {
+    switch (value) {
+        case "blue":
+            return "blueBright";
+        case "success":
+            return "green";
+        case "warning":
+            return "yellow";
+        case "danger":
+            return "red";
+        default:
+            return "gray";
+    }
+}
+export const DOT = "●";
+export const ARROW = "→";
+export const BAR = "│";
+export const ELLIPSIS = "…";

package/dist/out.js

@@ -65,7 +65,7 @@ export function usage() {
         c.bold("Usage"),
         `  ${c.blue("hd status")}                         workspace overview`,
         `  ${c.blue("hd ticket list | show | new")}       ticket operations`,
-        `  ${c.blue("hd workspace new")}                  create a paused workspace`,
+        `  ${c.blue("hd workspace ls | new")}             list or create workspaces`,
         `  ${c.blue("hd agents [set]")}                   inspect or update agents`,
         `  ${c.blue("hd logs KEY [-f]")}                  run events`,
         `  ${c.blue("hd msg KEY TEXT")}                   message a builder`,