orkestrate 0.1.14 → 0.2.0

package/src/cli/tui.ts

@@ -0,0 +1,355 @@
+import { createCliRenderer, Box, Text, CliRenderer } from "@opentui/core";
+import type { KeyEvent, Renderable } from "@opentui/core";
+import { runWelcomeWizard } from "./ui/welcome";
+import { loadExtensions } from "../sdk/extensions/loader";
+import type { Pack } from "../sdk/packs/schema";
+import {
+  installCatalogPack,
+  listFullCatalog,
+  listInstalledPacks,
+  type CatalogEntry,
+} from "../sdk/packs/catalog";
+import { launchPack, stopRun } from "../sdk/launch/broker";
+import { activeRunsForPack, listRuns, reconcileRuns } from "../sdk/runs/registry";
+import type { RunRecord } from "../sdk/runs/types";
+
+type PackView = "installed" | "browse";
+
+const VERSION = "0.2.0";
+const ROOT_LAYOUT_ID = "root-layout";
+const REFRESH_MS = 1500;
+
+const COLORS = {
+  bg: "#111113",
+  panel: "#18181b",
+  selected: "#252529",
+  text: "#f3f3f4",
+  muted: "#9b9ba1",
+  dim: "#6f6f76",
+  faint: "#4e4e55",
+  accent: "#d97757",
+  green: "#7fc18b",
+  blue: "#6aa6f8",
+};
+
+function clearChildren(node: Renderable) {
+  for (const child of [...node.getChildren()]) {
+    if (child.id) node.remove(child.id);
+  }
+}
+
+function truncate(value: string, max: number): string {
+  if (value.length <= max) return value;
+  return value.slice(0, max - 1) + "…";
+}
+
+const CSI_ARROW_UP = /\x1b\[[0-9;]*A$/;
+const CSI_ARROW_DOWN = /\x1b\[[0-9;]*B$/;
+
+function keyAction(key: KeyEvent): string | null {
+  const n = key.name?.toLowerCase();
+  const seq = key.sequence ?? "";
+
+  if (
+    n === "up" ||
+    n === "k" ||
+    seq === "\x1b[A" ||
+    seq === "\x1bOA" ||
+    CSI_ARROW_UP.test(seq)
+  ) {
+    return "up";
+  }
+  if (
+    n === "down" ||
+    n === "j" ||
+    seq === "\x1b[B" ||
+    seq === "\x1bOB" ||
+    CSI_ARROW_DOWN.test(seq)
+  ) {
+    return "down";
+  }
+  if (n === "return" || n === "enter") return "return";
+  if (n === "escape") return "escape";
+  if (n === "q" && !key.ctrl) return "quit";
+  if (key.ctrl && n === "c") return "quit";
+  if (n === "b") return "browse";
+  if (n === "i") return "installed";
+  if (n === "l") return "launch";
+  if (n === "s") return "stop";
+  return n ?? null;
+}
+
+function packStatusLine(runs: RunRecord[], packId: string): string {
+  const active = activeRunsForPack(runs, packId);
+  if (active.length === 0) return "idle";
+  if (active.length === 1) return `● running (${active[0]!.id})`;
+  return `● running ×${active.length}`;
+}
+
+export async function runTui(): Promise<void> {
+  await loadExtensions();
+
+  let renderer: CliRenderer;
+  const isWindows = process.platform === "win32";
+  try {
+    renderer = await createCliRenderer({
+      exitOnCtrlC: false,
+      backgroundColor: COLORS.bg,
+      useKittyKeyboard: isWindows ? null : undefined,
+    });
+    renderer.start();
+  } catch (error) {
+    console.error("Failed to initialize TUI:", error);
+    process.exit(1);
+  }
+
+  let installed = await listInstalledPacks();
+  if (installed.length === 0) {
+    await runWelcomeWizard(renderer);
+    clearChildren(renderer.root);
+    installed = await listInstalledPacks();
+  }
+
+  let catalog: CatalogEntry[] = await listFullCatalog();
+  let runs: RunRecord[] = await listRuns();
+  let packView: PackView = "installed";
+  let selectedIndex = 0;
+  let busy = false;
+  let message = "";
+
+  const packs = () => installed.map((l) => l.pack);
+
+  async function refresh() {
+    await reconcileRuns();
+    runs = await listRuns();
+    installed = await listInstalledPacks();
+    catalog = await listFullCatalog();
+  }
+
+  function listCount(): number {
+    if (packView === "browse") return catalog.length;
+    return packs().length;
+  }
+
+  function selectedPack(): Pack | undefined {
+    if (packView === "browse") return catalog[selectedIndex]?.pack;
+    return packs()[selectedIndex];
+  }
+
+  function render() {
+    renderer.currentFocusedRenderable?.blur();
+    clearChildren(renderer.root);
+    const count = listCount();
+    selectedIndex = Math.min(selectedIndex, Math.max(0, count - 1));
+
+    const rows: any[] = [];
+    const title = packView === "browse" ? "Browse packs" : "Packs";
+
+    if (packView === "installed") {
+      for (let i = 0; i < packs().length; i++) {
+        const p = packs()[i]!;
+        const sel = i === selectedIndex;
+        const status = packStatusLine(runs, p.id);
+        const statusColor =
+          status === "idle" ? COLORS.dim : status.startsWith("●") ? COLORS.green : COLORS.muted;
+        rows.push(
+          Box(
+            {
+              id: `row-${i}`,
+              paddingLeft: 2,
+              paddingTop: 1,
+              backgroundColor: sel ? COLORS.selected : COLORS.panel,
+              marginBottom: 1,
+            },
+            Text({ content: (sel ? "› " : "  ") + p.id, fg: sel ? COLORS.text : COLORS.muted }),
+            Text({ content: truncate(p.description, 56), fg: COLORS.dim }),
+            Text({ content: status, fg: statusColor })
+          )
+        );
+      }
+    } else {
+      for (let i = 0; i < catalog.length; i++) {
+        const e = catalog[i]!;
+        const sel = i === selectedIndex;
+        rows.push(
+          Box(
+            {
+              id: `row-${i}`,
+              paddingLeft: 2,
+              paddingTop: 1,
+              backgroundColor: sel ? COLORS.selected : COLORS.panel,
+              marginBottom: 1,
+            },
+            Text({
+              content:
+                (sel ? "› " : "  ") +
+                e.pack.id +
+                (e.source === "registry" ? " [registry]" : "") +
+                (e.installed ? " [installed]" : ""),
+              fg: sel ? COLORS.text : COLORS.muted,
+            }),
+            Text({ content: truncate(e.pack.description, 70), fg: COLORS.dim })
+          )
+        );
+      }
+    }
+
+    const footer =
+      packView === "browse"
+        ? "↑↓ move  Enter install  i installed  q quit"
+        : "↑↓ move  Enter launch  l launch  s stop active  b browse  q quit";
+
+    renderer.root.add(
+      Box(
+        {
+          id: ROOT_LAYOUT_ID,
+          focusable: true,
+          live: true,
+          flexDirection: "column",
+          width: "100%",
+          height: "100%",
+          backgroundColor: COLORS.bg,
+        },
+        Box({ id: "header", paddingLeft: 2, paddingTop: 1 }, Text({ content: `Orkestrate v${VERSION}`, fg: COLORS.text })),
+        Box({ id: "subtitle", paddingLeft: 2 }, Text({ content: title, fg: COLORS.muted })),
+        Box({ id: "list", flexGrow: 1, flexDirection: "column", paddingTop: 1 }, ...rows),
+        Box({ id: "footer", paddingLeft: 2, paddingBottom: 1 }, Text({ content: message || footer, fg: COLORS.faint }))
+      )
+    );
+
+    const layout = renderer.root.getRenderable(ROOT_LAYOUT_ID);
+    layout?.focus();
+    renderer.requestRender();
+  }
+
+  async function stopActiveForPack(packId: string) {
+    const active = activeRunsForPack(runs, packId);
+    for (const run of active) {
+      await stopRun(run.id);
+    }
+    return active.length;
+  }
+
+  async function handleKey(key: KeyEvent) {
+    if (busy) return;
+    const action = keyAction(key);
+    if (!action) return;
+
+    if (action === "quit") {
+      renderer.keyInput.off("keypress", onKeyPress);
+      renderer.destroy();
+      process.exit(0);
+    }
+
+    if (action === "browse") {
+      packView = "browse";
+      selectedIndex = 0;
+      render();
+      return;
+    }
+
+    if (action === "installed") {
+      packView = "installed";
+      selectedIndex = 0;
+      render();
+      return;
+    }
+
+    if (action === "escape") {
+      if (packView === "browse") {
+        packView = "installed";
+        selectedIndex = 0;
+        render();
+      }
+      return;
+    }
+
+    if (action === "up") {
+      selectedIndex = Math.max(0, selectedIndex - 1);
+      render();
+      return;
+    }
+
+    if (action === "down") {
+      selectedIndex = Math.min(listCount() - 1, selectedIndex + 1);
+      render();
+      return;
+    }
+
+    if (action === "stop") {
+      if (packView !== "installed") return;
+      const pack = selectedPack();
+      if (!pack) return;
+      busy = true;
+      try {
+        const n = await stopActiveForPack(pack.id);
+        message = n > 0 ? `Stopped ${n} session(s) for ${pack.id}` : `${pack.id} is idle`;
+        await refresh();
+      } catch (e) {
+        message = e instanceof Error ? e.message : String(e);
+      }
+      busy = false;
+      render();
+      return;
+    }
+
+    if (action === "launch") {
+      if (packView !== "installed") return;
+      const pack = selectedPack();
+      if (!pack) return;
+      busy = true;
+      try {
+        await launchPack(pack.id);
+        message = `Launched ${pack.id} in new terminal`;
+        await refresh();
+      } catch (e) {
+        message = e instanceof Error ? e.message : String(e);
+      }
+      busy = false;
+      render();
+      return;
+    }
+
+    if (action === "return") {
+      busy = true;
+      try {
+        if (packView === "browse") {
+          const entry = catalog[selectedIndex];
+          if (entry && !entry.installed) {
+            await installCatalogPack(entry.slug);
+            message = `Installed ${entry.pack.id}`;
+            await refresh();
+            packView = "installed";
+          }
+        } else {
+          const pack = selectedPack();
+          if (pack) {
+            await launchPack(pack.id);
+            message = `Launched ${pack.id} in new terminal`;
+            await refresh();
+          }
+        }
+      } catch (e) {
+        message = e instanceof Error ? e.message : String(e);
+      }
+      busy = false;
+      render();
+    }
+  }
+
+  const onKeyPress = (key: KeyEvent) => {
+    void handleKey(key);
+  };
+  renderer.keyInput.on("keypress", onKeyPress);
+
+  await refresh();
+  render();
+  renderer.root.getRenderable(ROOT_LAYOUT_ID)?.focus();
+
+  setInterval(() => {
+    if (busy) return;
+    void refresh().then(() => render());
+  }, REFRESH_MS);
+
+  await new Promise<void>(() => {});
+}

package/src/cli/ui/welcome.ts

@@ -0,0 +1,73 @@
+import { Box, Text, type KeyEvent, type Renderable } from "@opentui/core";
+import { join } from "node:path";
+import { installPackFromDirectory } from "../../sdk/packs/store";
+
+function clearChildren(node: Renderable) {
+  for (const child of [...node.getChildren()]) {
+    if (child.id) node.remove(child.id);
+  }
+}
+
+const COLORS = {
+  bg: "#111113",
+  panel: "#18181b",
+  text: "#f3f3f4",
+  muted: "#9b9ba1",
+  dim: "#6f6f76",
+  accent: "#d97757",
+};
+
+export async function runWelcomeWizard(renderer: any): Promise<void> {
+  return new Promise((resolve) => {
+    const container = Box(
+      {
+        width: "100%",
+        height: "100%",
+        justifyContent: "center",
+        alignItems: "center",
+        flexDirection: "column",
+        backgroundColor: COLORS.bg,
+      },
+      Box(
+        {
+          flexDirection: "column",
+          width: 72,
+          paddingLeft: 4,
+          paddingRight: 4,
+          paddingTop: 2,
+          paddingBottom: 2,
+          backgroundColor: COLORS.panel,
+        },
+        Text({ content: "Orkestrate", fg: COLORS.text }),
+        Text({ content: "Control room for OpenCode packs in this workspace.", fg: COLORS.muted }),
+        Box({ height: 2 }),
+        Text({ content: "No packs are installed yet.", fg: COLORS.muted }),
+        Text({ content: "Install the coding pack to get started.", fg: COLORS.muted }),
+        Box({ height: 2 }),
+        Text({ content: "Press Enter to install coding", fg: COLORS.accent }),
+        Text({ content: "Press Ctrl+C to exit", fg: COLORS.dim })
+      )
+    );
+
+    renderer.root.add(container);
+
+    const onKey = async (key: KeyEvent) => {
+      if (key.name !== "return") return;
+
+      renderer.keyInput.off("keypress", onKey);
+
+      try {
+        const moduleDir = import.meta.dir ?? process.cwd();
+        const codingPack = join(moduleDir, "..", "..", "..", "packs", "coding");
+        await installPackFromDirectory(codingPack, { target: "global" });
+      } catch (error) {
+        console.error("Failed to install coding pack", error);
+      }
+
+      clearChildren(renderer.root);
+      resolve();
+    };
+
+    renderer.keyInput.on("keypress", onKey);
+  });
+}

package/src/cli.ts

@@ -0,0 +1 @@
+import "./cli/index";

package/src/sdk/cross-platform.ts

@@ -0,0 +1,25 @@
+import type { CrossPlatformUtility } from "./types";
+import * as path from "path";
+
+export const crossPlatformUtility: CrossPlatformUtility = {
+  hijackHome(fakeHomePath: string): Record<string, string> {
+    const isWindowsPath = fakeHomePath.includes(":\\") || fakeHomePath.includes(":/");
+    
+    const envVars: Record<string, string> = {
+      HOME: fakeHomePath,
+      USERPROFILE: fakeHomePath,
+      APPDATA: fakeHomePath,
+      XDG_CONFIG_HOME: path.join(fakeHomePath, ".config"),
+      XDG_DATA_HOME: path.join(fakeHomePath, ".local", "share"),
+      XDG_STATE_HOME: path.join(fakeHomePath, ".local", "state"),
+      XDG_CACHE_HOME: path.join(fakeHomePath, ".cache"),
+    };
+
+    if (isWindowsPath) {
+      envVars.HOMEDRIVE = fakeHomePath.substring(0, 2);
+      envVars.HOMEPATH = fakeHomePath.substring(2);
+    }
+
+    return envVars;
+  }
+};

package/src/sdk/extensions/loader.ts

@@ -0,0 +1,89 @@
+import { readdir, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { registry } from "../registry";
+import type { ExtensionContext, OrkExtension } from "./types";
+
+const context: ExtensionContext = {
+  registerAdapter(harness, adapter) {
+    registry.registerAdapter(harness, adapter);
+  },
+};
+
+async function getSubdirectories(dir: string): Promise<string[]> {
+  try {
+    const entries = await readdir(dir);
+    const subdirs: string[] = [];
+    for (const entry of entries) {
+      const fullPath = join(dir, entry);
+      const s = await stat(fullPath);
+      if (s.isDirectory()) {
+        subdirs.push(fullPath);
+      }
+    }
+    return subdirs;
+  } catch {
+    return [];
+  }
+}
+
+export async function loadExtensions(): Promise<void> {
+  const baseDir = import.meta.dir ?? process.cwd();
+  const bundledDir = join(baseDir, "..", "..", "..", "extensions");
+  const globalDir = join(homedir(), ".orkestrate", "extensions");
+  const workspaceDir = join(process.cwd(), ".orkestrate", "extensions");
+
+  const pathsToScan = [bundledDir, globalDir, workspaceDir];
+  const extensionDirs: string[] = [];
+
+  for (const dir of pathsToScan) {
+    const subdirs = await getSubdirectories(dir);
+    for (const subdir of subdirs) {
+      if (!extensionDirs.includes(subdir)) {
+        extensionDirs.push(subdir);
+      }
+    }
+  }
+
+  for (const dir of extensionDirs) {
+    try {
+      // Only attempt to load if it has an entry point or package.json
+      const hasEntryPoint = 
+        await Bun.file(join(dir, "index.ts")).exists() ||
+        await Bun.file(join(dir, "index.js")).exists() ||
+        await Bun.file(join(dir, "package.json")).exists();
+
+      if (!hasEntryPoint) {
+        continue;
+      }
+
+      // Bun/Node import supports importing directory directly (using index.ts / index.js / package.json)
+      const mod = await import(dir);
+      
+      // Look for standard exports: default or named
+      const raw = mod.default || mod.extension || mod;
+
+      if (typeof raw !== "object" || raw === null) {
+        console.warn(`Extension at "${dir}" does not export a valid object — skipping`);
+        continue;
+      }
+
+      // Validate OrkExtension shape before activating
+      const missing: string[] = [];
+      if (typeof raw.id !== "string" || !raw.id) missing.push("id");
+      if (typeof raw.name !== "string" || !raw.name) missing.push("name");
+      if (typeof raw.version !== "string" || !raw.version) missing.push("version");
+      if (typeof raw.activate !== "function") missing.push("activate");
+      if (missing.length > 0) {
+        console.warn(`Extension at "${dir}" is missing required field(s): ${missing.join(", ")} — skipping`);
+        continue;
+      }
+
+      const ext = raw as OrkExtension;
+      await ext.activate(context);
+    } catch (error) {
+      // Don't let one failing extension crash the entire loader
+      console.warn(`Failed to load extension at "${dir}":`, error);
+    }
+  }
+}