orkestrate 0.1.14 → 0.2.0

package/src/cli/cmd/profile-submit.ts

@@ -0,0 +1,236 @@
+import { listProfiles, loadProfile } from "../../sdk/profiles/load";
+import { parseProfile, type Profile } from "../../sdk/profiles/schema";
+
+const GREEN = "\x1b[32m";
+const RED = "\x1b[31m";
+const YELLOW = "\x1b[33m";
+const BOLD = "\x1b[1m";
+const RESET = "\x1b[0m";
+const BLUE = "\x1b[34m";
+
+const REGISTRY_URL = process.env.ORKESTRATE_REGISTRY_URL || "https://orkestrate.space/api/registry";
+
+export async function runProfileSubmit(name: string): Promise<void> {
+  const profiles = await listProfiles({ warn: true });
+  const profile = profiles.find((p: { name: string }) => p.name === name);
+
+  if (!profile) {
+    console.error(`${RED}Error:${RESET} Profile "${name}" not found`);
+    process.exitCode = 1;
+    return;
+  }
+
+  console.log(`${BOLD}Submitting profile: ${profile.name}${RESET}`);
+  console.log("");
+
+  // Load full profile with source path
+  let fullProfile: Profile;
+  try {
+    fullProfile = await loadProfile(profile.name);
+  } catch (error) {
+    console.error(`${RED}Error:${RESET} Failed to load profile:`, error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+    return;
+  }
+
+  // Validate
+  try {
+    parseProfile(fullProfile);
+  } catch (error) {
+    console.error(`${RED}Error:${RESET} Profile validation failed:`, error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+    return;
+  }
+
+  console.log(`${GREEN}✓${RESET} Profile validation passed`);
+  console.log("");
+
+  // Check for existing auth token
+  const token = await getAuthToken();
+  if (!token) {
+    console.log(`${YELLOW}Authentication required${RESET}`);
+    console.log("This will open a browser window for GitHub OAuth via Supabase.");
+    console.log("");
+    
+    const proceed = await confirm("Continue with authentication?");
+    if (!proceed) {
+      console.log("Cancelled.");
+      return;
+    }
+
+    // Start device flow or web auth
+    const authResult = await startAuthFlow();
+    if (!authResult) {
+      console.error(`${RED}Error:${RESET} Authentication failed or cancelled`);
+      process.exitCode = 1;
+      return;
+    }
+  }
+
+  // Submit to registry
+  console.log(`${BLUE}Submitting to registry...${RESET}`);
+  try {
+    const response = await fetch(`${REGISTRY_URL}/submit`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${token}`,
+      },
+      body: JSON.stringify({
+        profile: fullProfile,
+        source: "cli",
+      }),
+    });
+
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ message: "Unknown error" }));
+      throw new Error(`Registry error: ${response.status} - ${error.message ?? "Unknown"}`);
+    }
+
+    const result = await response.json();
+    console.log(`${GREEN}✓${RESET} Profile submitted successfully!`);
+    console.log("");
+    console.log(`Submission ID: ${result.submission_id}`);
+    console.log(`Status: ${result.status}`);
+    console.log(`Review URL: ${result.review_url ?? "N/A"}`);
+    console.log("");
+    console.log("The Orkestrate team will review your submission.");
+    console.log("You'll receive a notification when the review is complete.");
+
+  } catch (error) {
+    console.error(`${RED}Error:${RESET} Submission failed:`, error instanceof Error ? error.message : String(error));
+    console.log("");
+    console.log("You can also submit manually by:");
+    console.log(`  1. Go to ${BLUE}https://orkestrate.space/submit${RESET}`);
+    console.log("  2. Sign in with GitHub");
+    console.log("  3. Paste the profile JSON or upload the file");
+    process.exitCode = 1;
+  }
+}
+
+async function getAuthToken(): Promise<string | null> {
+  // Check for stored token (in ~/.orkestrate/auth.json or env)
+  const authPath = `${process.env.HOME || process.env.USERPROFILE}/.orkestrate/auth.json`;
+  try {
+    const file = Bun.file(authPath);
+    if (await file.exists()) {
+      const auth = await file.json();
+      if (auth.access_token && auth.expires_at && Date.now() < auth.expires_at) {
+        return auth.access_token;
+      }
+    }
+  } catch {}
+  
+  // Check env var
+  if (process.env.ORKESTRATE_AUTH_TOKEN) {
+    return process.env.ORKESTRATE_AUTH_TOKEN;
+  }
+  
+  return null;
+}
+
+async function startAuthFlow(): Promise<string | null> {
+  // Use Supabase device flow or redirect to web auth
+  console.log(`${BLUE}Opening browser for GitHub authentication...${RESET}`);
+  
+  const authUrl = `${REGISTRY_URL}/auth/device`;
+  try {
+    const response = await fetch(authUrl, { method: "POST" });
+    const data = await response.json();
+    
+    if (data.device_code && data.verification_uri_complete) {
+      // Open browser
+      const { spawn } = await import("node:child_process");
+      const url = data.verification_uri_complete;
+      
+      let opened = false;
+      if (process.platform === "darwin") {
+        spawn("open", [url]);
+        opened = true;
+      } else if (process.platform === "win32") {
+        spawn("cmd", ["/c", "start", url]);
+        opened = true;
+      } else if (process.platform === "linux") {
+        spawn("xdg-open", [url]);
+        opened = true;
+      }
+      
+      if (!opened) {
+        console.log(`Please open this URL in your browser: ${BLUE}${url}${RESET}`);
+      }
+      
+      console.log(`Or visit: ${BLUE}${data.verification_uri}${RESET} and enter code: ${BOLD}${data.user_code}${RESET}`);
+      console.log("");
+      console.log("Waiting for authentication...");
+      
+      // Poll for token
+      const token = await pollForToken(data.device_code, data.interval ?? 5);
+      return token;
+    }
+  } catch (error) {
+    console.error("Auth flow error:", error);
+  }
+  
+  return null;
+}
+
+async function pollForToken(deviceCode: string, interval: number): Promise<string | null> {
+  const maxAttempts = 180 / interval; // 3 minutes max
+  
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    await new Promise(r => setTimeout(r, interval * 1000));
+    
+    try {
+      const response = await fetch(`${REGISTRY_URL}/auth/token`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ device_code: deviceCode, grant_type: "urn:ietf:params:oauth:grant-type:device_code" }),
+      });
+      
+      if (response.ok) {
+        const data = await response.json();
+        if (data.access_token) {
+          // Save token
+          const authPath = `${process.env.HOME || process.env.USERPROFILE}/.orkestrate/auth.json`;
+          await Bun.write(authPath, JSON.stringify({
+            access_token: data.access_token,
+            refresh_token: data.refresh_token,
+            expires_at: Date.now() + (data.expires_in * 1000),
+          }, null, 2));
+          
+          console.log(`${GREEN}✓${RESET} Authentication successful!`);
+          return data.access_token;
+        }
+      } else if (response.status === 400) {
+        const error = await response.json().catch(() => ({}));
+        if (error.error === "authorization_pending") {
+          continue; // Keep polling
+        } else if (error.error === "slow_down") {
+          interval += 5;
+          continue;
+        } else if (error.error === "expired_token") {
+          console.log("Authentication expired. Please try again.");
+          return null;
+        } else if (error.error === "access_denied") {
+          console.log("Authentication denied.");
+          return null;
+        }
+      }
+    } catch (error) {
+      console.error("Polling error:", error);
+    }
+  }
+  
+  console.log("Authentication timed out.");
+  return null;
+}
+
+function confirm(message: string): Promise<boolean> {
+  return new Promise(resolve => {
+    console.log(`${message} (y/N): `);
+    process.stdin.once("data", data => {
+      const input = data.toString().trim().toLowerCase();
+      resolve(input === "y" || input === "yes");
+    });
+  });
+}

package/src/cli/cmd/profile-validate.ts

@@ -0,0 +1,5 @@
+import { runPackValidate } from "./pack";
+
+export async function runProfileValidate(name: string): Promise<void> {
+  await runPackValidate(name);
+}

package/src/cli/cmd/registry.ts

@@ -0,0 +1,66 @@
+import {
+  installCatalogPack,
+  listBundledCatalog,
+  listFullCatalog,
+  listRegistryCatalog,
+} from "../../sdk/packs/catalog";
+import { REGISTRY_URL } from "../../sdk/packs/registry";
+
+export async function runRegistryList(): Promise<void> {
+  const bundled = await listBundledCatalog();
+  console.log("Bundled packs:\n");
+  for (const e of bundled) {
+    console.log(`  ${e.slug}  ${e.pack.description}`);
+  }
+
+  try {
+    const remote = await listRegistryCatalog();
+    if (remote.length === 0) {
+      console.log(`\nRegistry (${REGISTRY_URL}): no installable packs.`);
+      return;
+    }
+    console.log(`\nRegistry (${REGISTRY_URL}):\n`);
+    for (const e of remote) {
+      const tag = e.installed ? " [installed]" : "";
+      console.log(`  ${e.slug}${tag}  ${e.description ?? e.pack.description}`);
+      if (e.github) console.log(`    ${e.github}`);
+    }
+  } catch (error) {
+    console.warn(`\nRegistry unavailable: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+export async function runRegistrySearch(query: string): Promise<void> {
+  const q = query.toLowerCase();
+  const all = await listFullCatalog();
+  const hits = all.filter(
+    (e) =>
+      e.slug.toLowerCase().includes(q) ||
+      e.pack.id.toLowerCase().includes(q) ||
+      e.pack.description.toLowerCase().includes(q) ||
+      (e.pack.name && e.pack.name.toLowerCase().includes(q))
+  );
+
+  if (hits.length === 0) {
+    console.log(`No packs matching "${query}".`);
+    return;
+  }
+
+  for (const e of hits) {
+    const src = e.source === "registry" ? "registry" : "bundled";
+    console.log(`${e.slug}  (${src})${e.installed ? " [installed]" : ""}`);
+    console.log(`  ${e.pack.description}`);
+  }
+}
+
+export async function runRegistryInstall(
+  slug: string,
+  options?: { global?: boolean; overwrite?: boolean }
+): Promise<void> {
+  const pack = await installCatalogPack(slug, {
+    target: options?.global ? "global" : "workspace",
+    overwrite: options?.overwrite,
+  });
+  console.log(`Installed pack: ${pack.id}`);
+  console.log(`  ${pack.packRoot}`);
+}

package/src/cli/cmd/run.ts

@@ -0,0 +1,37 @@
+import { launchPack, stopRun } from "../../sdk/launch/broker";
+import { getRun, listRuns, reconcileRuns } from "../../sdk/runs/registry";
+
+export async function runLaunch(packId: string): Promise<void> {
+  const run = await launchPack(packId);
+  console.log(`runId=${run.id}`);
+  console.log(`pack=${run.packId}`);
+  console.log(`state=${run.state}`);
+  console.log(`Opened new terminal: ${run.title}`);
+}
+
+export async function runSpawn(packId: string): Promise<void> {
+  await runLaunch(packId);
+}
+
+export async function runList(): Promise<void> {
+  await reconcileRuns();
+  const runs = await listRuns();
+  if (runs.length === 0) {
+    console.log("No runs.");
+    return;
+  }
+  for (const run of runs) {
+    console.log(`${run.id}  ${run.packId}  ${run.state}  ${run.startedAt}`);
+    if (run.pid) console.log(`  pid=${run.pid}`);
+  }
+}
+
+export async function runStatus(runId: string): Promise<void> {
+  const run = await getRun(runId);
+  console.log(JSON.stringify(run, null, 2));
+}
+
+export async function runStop(runId: string): Promise<void> {
+  const run = await stopRun(runId);
+  console.log(`Stopped ${run.id} (${run.state})`);
+}

package/src/cli/index.ts

@@ -0,0 +1,163 @@
+import { loadExtensions } from "../sdk/extensions/loader";
+import { runTui } from "./tui";
+import { listInstalledPacks } from "../sdk/packs/catalog";
+import { getAdapter } from "../sdk/registry";
+import { VERSION } from "../version";
+
+await loadExtensions();
+
+const command = Bun.argv[2];
+
+if (!command) {
+  await runTui();
+} else if (command === "doctor") {
+  const installed = await listInstalledPacks();
+  console.log(`Orkestrate Doctor v${VERSION}`);
+  console.log(`Packs: ${installed.length}`);
+  for (const { pack } of installed) {
+    const adapter = getAdapter(pack.harness);
+    const status = adapter ? await adapter.detect() : { installed: false, error: "no driver" };
+    console.log(`  ${pack.id}: ${pack.harness} (${status.installed ? "ok" : status.error ?? "missing"})`);
+  }
+} else if (command === "pack") {
+  const sub = Bun.argv[3];
+  if (sub === "list") {
+    const { runPackList } = await import("./cmd/pack");
+    await runPackList();
+  } else if (sub === "install") {
+    const slug = Bun.argv[4];
+    if (!slug) {
+      console.error("Usage: orkestrate pack install <slug> [--global]");
+      process.exit(1);
+    }
+    const { runPackInstall } = await import("./cmd/pack");
+    await runPackInstall(slug, Bun.argv.includes("--global"));
+  } else if (sub === "validate") {
+    const id = Bun.argv[4];
+    if (!id) {
+      console.error("Usage: orkestrate pack validate <pack-id>");
+      process.exit(1);
+    }
+    const { runPackValidate } = await import("./cmd/pack");
+    await runPackValidate(id);
+  } else if (sub === "create") {
+    const id = Bun.argv[4];
+    if (!id) {
+      console.error("Usage: orkestrate pack create <pack-id> [--from coding] [--description \"...\"] [--global]");
+      process.exit(1);
+    }
+    const fromIdx = Bun.argv.indexOf("--from");
+    const descIdx = Bun.argv.indexOf("--description");
+    const { runPackCreate } = await import("./cmd/pack-create");
+    await runPackCreate(id, {
+      template: fromIdx >= 0 ? Bun.argv[fromIdx + 1] : undefined,
+      description: descIdx >= 0 ? Bun.argv[descIdx + 1] : undefined,
+      global: Bun.argv.includes("--global"),
+    });
+  } else {
+    console.error("Usage: orkestrate pack <list|install|validate|create>");
+    process.exit(1);
+  }
+} else if (command === "run") {
+  const sub = Bun.argv[3];
+  if (sub === "launch" || sub === "spawn") {
+    const packId = Bun.argv[4];
+    if (!packId) {
+      console.error(`Usage: orkestrate run ${sub} <pack-id>`);
+      process.exit(1);
+    }
+    const { runLaunch, runSpawn } = await import("./cmd/run");
+    if (sub === "spawn") await runSpawn(packId);
+    else await runLaunch(packId);
+  } else if (sub === "list") {
+    const { runList } = await import("./cmd/run");
+    await runList();
+  } else if (sub === "status") {
+    const id = Bun.argv[4];
+    if (!id) {
+      console.error("Usage: orkestrate run status <run-id>");
+      process.exit(1);
+    }
+    const { runStatus } = await import("./cmd/run");
+    await runStatus(id);
+  } else if (sub === "stop") {
+    const id = Bun.argv[4];
+    if (!id) {
+      console.error("Usage: orkestrate run stop <run-id>");
+      process.exit(1);
+    }
+    const { runStop } = await import("./cmd/run");
+    await runStop(id);
+  } else {
+    console.error("Usage: orkestrate run <launch|spawn|list|status|stop>");
+    process.exit(1);
+  }
+} else if (command === "profile") {
+  const sub = Bun.argv[3];
+  if (sub === "validate") {
+    const name = Bun.argv[4];
+    if (!name) {
+      console.error("Usage: orkestrate profile validate <pack-id>");
+      process.exit(1);
+    }
+    const { runPackValidate } = await import("./cmd/pack");
+    await runPackValidate(name);
+  } else if (sub === "create") {
+    console.error("Use: orkestrate pack create <pack-id> [--from coding] [--global]");
+    process.exit(1);
+  } else {
+    console.error("Profile commands are deprecated. Use: orkestrate pack … / orkestrate run …");
+    process.exit(1);
+  }
+} else if (command === "registry") {
+  const subCommand = Bun.argv[3];
+  if (subCommand === "list") {
+    const { runRegistryList } = await import("./cmd/registry");
+    await runRegistryList();
+  } else if (subCommand === "search") {
+    const query = Bun.argv[4];
+    if (!query) {
+      console.error("Usage: orkestrate registry search <query>");
+      process.exit(1);
+    }
+    const { runRegistrySearch } = await import("./cmd/registry");
+    await runRegistrySearch(query);
+  } else if (subCommand === "install") {
+    const slug = Bun.argv[4];
+    if (!slug) {
+      console.error("Usage: orkestrate registry install <slug> [--global] [--overwrite]");
+      process.exit(1);
+    }
+    const { runRegistryInstall } = await import("./cmd/registry");
+    await runRegistryInstall(slug, {
+      global: Bun.argv.includes("--global"),
+      overwrite: Bun.argv.includes("--overwrite"),
+    });
+  } else {
+    console.error("Usage: orkestrate registry <list|search|install>");
+    process.exit(1);
+  }
+} else if (command === "extension" && Bun.argv[3] === "validate") {
+  const target = Bun.argv[4];
+  if (!target) {
+    console.error("Usage: orkestrate extension validate <path>");
+    process.exit(1);
+  }
+  const { resolve } = await import("node:path");
+  try {
+    const mod = await import(resolve(target));
+    const ext = mod.default || mod.extension || mod;
+    console.log("Extension valid:", ext.id, ext.version);
+  } catch (error) {
+    console.error(error);
+    process.exit(1);
+  }
+} else {
+  console.log(`Orkestrate v${VERSION}`);
+  console.log("Commands:");
+  console.log("  orkestrate              TUI workbench");
+  console.log("  orkestrate pack list|install|validate|create");
+  console.log("  orkestrate registry list|search|install");
+  console.log("  orkestrate run launch|spawn|list|status|stop");
+  console.log("  orkestrate doctor");
+}