orkestrate 0.1.14 → 0.2.0

package/src/sdk/extensions/manifest.ts

@@ -0,0 +1,193 @@
+export type ExtensionType = 
+  | "adapter"
+  | "profile-pack"
+  | "skill-pack"
+  | "mcp-pack"
+  | "command-pack";
+
+export interface ExtensionManifest {
+  id: string;
+  name: string;
+  version: string;
+  type: ExtensionType;
+  description: string;
+  author?: string;
+  repository?: string;
+  license?: string;
+  keywords?: string[];
+  
+  // Entry point
+  entry: string;
+  
+  // Type-specific fields
+  harness?: string;           // for adapter type
+  capabilities?: {            // for adapter type
+    mcp?: boolean;
+    systemPrompt?: boolean;
+    skills?: boolean;
+    modelSelection?: boolean;
+  };
+  
+  profiles?: string[];        // for profile-pack type
+  skills?: string[];          // for skill-pack type
+  mcpServers?: string[];      // for mcp-pack type
+  commands?: string[];        // for command-pack type
+  
+  // Dependencies
+  dependencies?: Record<string, string>;
+  peerDependencies?: Record<string, string>;
+  
+  // Compatibility
+  orkestrateVersion?: string;
+  minOrkestrateVersion?: string;
+}
+
+export const EXTENSION_MANIFEST_SCHEMA = {
+  type: "object",
+  required: ["id", "name", "version", "type", "description", "entry"],
+  properties: {
+    id: { type: "string", pattern: "^orkestrate\\.[a-z-]+\\.[a-z0-9-]+$" },
+    name: { type: "string", minLength: 1 },
+    version: { type: "string", pattern: "^\\d+\\.\\d+\\.\\d+(-.*)?$" },
+    type: { type: "string", enum: ["adapter", "profile-pack", "skill-pack", "mcp-pack", "command-pack"] },
+    description: { type: "string", minLength: 10 },
+    author: { type: "string" },
+    repository: { type: "string", format: "uri" },
+    license: { type: "string" },
+    keywords: { type: "array", items: { type: "string" } },
+    entry: { type: "string", minLength: 1 },
+    harness: { type: "string" },
+    capabilities: {
+      type: "object",
+      properties: {
+        mcp: { type: "boolean" },
+        systemPrompt: { type: "boolean" },
+        skills: { type: "boolean" },
+        modelSelection: { type: "boolean" },
+      },
+    },
+    profiles: { type: "array", items: { type: "string" } },
+    skills: { type: "array", items: { type: "string" } },
+    mcpServers: { type: "array", items: { type: "string" } },
+    commands: { type: "array", items: { type: "string" } },
+    dependencies: { type: "object", additionalProperties: { type: "string" } },
+    peerDependencies: { type: "object", additionalProperties: { type: "string" } },
+    orkestrateVersion: { type: "string" },
+    minOrkestrateVersion: { type: "string" },
+  },
+} as const;
+
+export function validateManifest(manifest: unknown): { valid: boolean; errors: string[] } {
+  const errors: string[] = [];
+  
+  if (!manifest || typeof manifest !== "object") {
+    return { valid: false, errors: ["Manifest must be an object"] };
+  }
+  
+  const m = manifest as Record<string, unknown>;
+  
+  // Required fields
+  for (const field of ["id", "name", "version", "type", "description", "entry"]) {
+    if (!m[field] || typeof m[field] !== "string") {
+      errors.push(`Missing or invalid required field: ${field}`);
+    }
+  }
+  
+  // Validate ID format
+  if (m.id && typeof m.id === "string") {
+    if (!/^orkestrate\.[a-z-]+\.[a-z0-9-]+$/.test(m.id)) {
+      errors.push('ID must follow format: orkestrate.<category>.<name> (e.g., "orkestrate.adapter.opencode")');
+    }
+  }
+  
+  // Validate version
+  if (m.version && typeof m.version === "string") {
+    if (!/^\d+\.\d+\.\d+(-.*)?$/.test(m.version)) {
+      errors.push('Version must follow semver (e.g., "1.0.0" or "1.0.0-beta")');
+    }
+  }
+  
+  // Validate type
+  const validTypes: ExtensionType[] = ["adapter", "profile-pack", "skill-pack", "mcp-pack", "command-pack"];
+  if (m.type && !validTypes.includes(m.type as ExtensionType)) {
+    errors.push(`Invalid type. Must be one of: ${validTypes.join(", ")}`);
+  }
+  
+  // Type-specific validation
+  if (m.type === "adapter") {
+    if (!m.harness || typeof m.harness !== "string") {
+      errors.push('Adapter type requires "harness" field (e.g., "opencode")');
+    }
+    if (!m.capabilities || typeof m.capabilities !== "object") {
+      errors.push('Adapter type requires "capabilities" object');
+    }
+  }
+  
+  if (m.type === "profile-pack") {
+    if (!m.profiles || !Array.isArray(m.profiles) || m.profiles.length === 0) {
+      errors.push('Profile-pack type requires non-empty "profiles" array');
+    }
+  }
+  
+  if (m.type === "skill-pack") {
+    if (!m.skills || !Array.isArray(m.skills) || m.skills.length === 0) {
+      errors.push('Skill-pack type requires non-empty "skills" array');
+    }
+  }
+  
+  return { valid: errors.length === 0, errors };
+}
+
+export function createManifestTemplate(type: ExtensionType): Partial<ExtensionManifest> {
+  const base = {
+    id: `orkestrate.${type}.my-extension`,
+    name: "My Extension",
+    version: "1.0.0",
+    type,
+    description: "A detailed description of what this extension does.",
+    author: "Your Name",
+    repository: "https://github.com/yourusername/your-repo",
+    license: "MIT",
+    keywords: ["orkestrate", type],
+    entry: "index.ts",
+  };
+  
+  switch (type) {
+    case "adapter":
+      return {
+        ...base,
+        id: "orkestrate.adapter.myharness",
+        harness: "myharness",
+        capabilities: {
+          mcp: true,
+          systemPrompt: true,
+          skills: true,
+          modelSelection: true,
+        },
+      };
+    case "profile-pack":
+      return {
+        ...base,
+        id: "orkestrate.profile-pack.mypack",
+        profiles: ["profile1", "profile2"],
+      };
+    case "skill-pack":
+      return {
+        ...base,
+        id: "orkestrate.skill-pack.myskills",
+        skills: ["skill1", "skill2"],
+      };
+    case "mcp-pack":
+      return {
+        ...base,
+        id: "orkestrate.mcp-pack.mymcps",
+        mcpServers: ["server1", "server2"],
+      };
+    case "command-pack":
+      return {
+        ...base,
+        id: "orkestrate.command-pack.mycommands",
+        commands: ["command1", "command2"],
+      };
+  }
+}

package/src/sdk/extensions/types.ts

@@ -0,0 +1,12 @@
+import type { HarnessDriver } from "../types";
+
+export interface ExtensionContext {
+  registerAdapter(harness: string, adapter: HarnessDriver): void;
+}
+
+export interface OrkExtension {
+  id: string;
+  name: string;
+  version: string;
+  activate(ctx: ExtensionContext): void | Promise<void>;
+}

package/src/sdk/harness/sync-slice.ts

@@ -0,0 +1,57 @@
+import { cp, mkdir, readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { pathExists } from "../packs/fs";
+
+/**
+ * Seed OpenCode config from a pack harness slice without clobbering user edits.
+ * - First launch: copy full slice.
+ * - Later launches: add missing agents/skills/plugins only; never overwrite opencode.json.
+ */
+export async function seedHarnessSlice(sliceDir: string, destDir: string): Promise<void> {
+  await mkdir(destDir, { recursive: true });
+
+  const destConfig = join(destDir, "opencode.json");
+  const isFirstSeed = !(await pathExists(destConfig));
+
+  if (isFirstSeed) {
+    await cp(sliceDir, destDir, { recursive: true, force: true });
+    return;
+  }
+
+  await mergeMissingSubtree(join(sliceDir, "agents"), join(destDir, "agents"));
+  await mergeMissingSubtree(join(sliceDir, "skills"), join(destDir, "skills"));
+  await mergeMissingSubtree(join(sliceDir, "plugins"), join(destDir, "plugins"));
+
+  for (const file of ["AGENTS.md", "README.md"]) {
+    const src = join(sliceDir, file);
+    const dst = join(destDir, file);
+    if ((await pathExists(src)) && !(await pathExists(dst))) {
+      await cp(src, dst, { force: true });
+    }
+  }
+}
+
+async function mergeMissingSubtree(srcDir: string, destDir: string): Promise<void> {
+  if (!(await pathExists(srcDir))) return;
+  await mkdir(destDir, { recursive: true });
+  await copyMissingRecursive(srcDir, destDir);
+}
+
+async function copyMissingRecursive(src: string, dest: string): Promise<void> {
+  const entries = await readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = join(src, entry.name);
+    const destPath = join(dest, entry.name);
+    if (entry.isDirectory()) {
+      if (!(await pathExists(destPath))) {
+        await mkdir(destPath, { recursive: true });
+      }
+      await copyMissingRecursive(srcPath, destPath);
+      continue;
+    }
+    if (!(await pathExists(destPath))) {
+      await mkdir(join(destPath, ".."), { recursive: true });
+      await cp(srcPath, destPath, { force: true });
+    }
+  }
+}

package/src/sdk/launch/broker.ts

@@ -0,0 +1,87 @@
+import { getAdapter } from "../registry";
+import type { Pack } from "../packs/schema";
+import { resolvePack } from "../packs/store";
+import { createRun, runDir, setRunState, updateRun } from "../runs/registry";
+import { packHomePath } from "../packs/paths";
+import { join } from "node:path";
+import { mkdir, writeFile } from "node:fs/promises";
+import type { RunRecord } from "../runs/types";
+import { openInNewTerminal } from "./terminal";
+import type { LaunchPlan } from "./types";
+import { crossPlatformUtility } from "../cross-platform";
+
+export type LaunchOptions = {
+  cwd?: string;
+  packId?: string;
+};
+
+export async function launchPack(packId: string, options: LaunchOptions = {}): Promise<RunRecord> {
+  const pack = await resolvePack(packId);
+  const cwd = options.cwd ?? process.cwd();
+  const adapter = getAdapter(pack.harness);
+  if (!adapter?.compile) {
+    throw new Error(`No driver registered for harness "${pack.harness}"`);
+  }
+
+  const { newRunId } = await import("../runs/registry");
+  const runId = newRunId();
+  const run = await createRun({
+    packId: pack.id,
+    harness: pack.harness,
+    cwd,
+    title: `orkestrate: ${pack.id} · ${runId}`,
+    runId,
+  });
+
+  const packHome = packHomePath(pack.id);
+  await mkdir(packHome, { recursive: true });
+
+  let plan: LaunchPlan;
+  try {
+    plan = await adapter.compile(pack, {
+      cwd,
+      runId: run.id,
+      packHome,
+      crossPlatform: crossPlatformUtility,
+    });
+    plan.title = run.title;
+  } catch (error) {
+    await setRunState(run.id, "failed", {
+      endedAt: new Date().toISOString(),
+    });
+    throw error;
+  }
+
+  const runnerScript = join(import.meta.dir, "runner.ts");
+  const dir = runDir(run.id);
+  await writeFile(join(dir, "launch.json"), JSON.stringify(plan, null, 2) + "\n");
+
+  try {
+    await openInNewTerminal({
+      plan,
+      runId: run.id,
+      runnerScript,
+      launchCmdPath: join(dir, "launch.cmd"),
+    });
+    return updateRun(run.id, { state: "starting" });
+  } catch (error) {
+    await setRunState(run.id, "failed", { endedAt: new Date().toISOString() });
+    throw error;
+  }
+}
+
+export async function stopRun(runId: string): Promise<RunRecord> {
+  const { getRun } = await import("../runs/registry");
+  const run = await getRun(runId);
+  if (run.pid) {
+    try {
+      process.kill(run.pid);
+    } catch {
+      // process may already be gone
+    }
+  }
+  return updateRun(runId, {
+    state: "stopped",
+    endedAt: new Date().toISOString(),
+  });
+}

package/src/sdk/launch/runner.ts

@@ -0,0 +1,57 @@
+/**
+ * Executed inside the new terminal window. Tracks the real agent PID and exit state.
+ * Usage: bun runner.ts <runId>
+ */
+import { spawn } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { updateRun, runDir } from "../runs/registry";
+import type { LaunchPlan } from "./types";
+
+const runId = process.argv[2];
+if (!runId) {
+  console.error("Usage: bun runner.ts <runId>");
+  process.exit(1);
+}
+
+const planPath = join(runDir(runId), "launch.json");
+const plan = JSON.parse(await readFile(planPath, "utf-8")) as LaunchPlan;
+
+await updateRun(runId, { state: "running" });
+
+const child = spawn(plan.command, plan.args, {
+  cwd: plan.cwd,
+  env: { ...process.env, ...plan.env },
+  stdio: "inherit",
+  shell: process.platform === "win32",
+});
+
+if (child.pid) {
+  await updateRun(runId, { pid: child.pid });
+}
+
+child.on("exit", (code, signal) => {
+  void (async () => {
+    const endedAt = new Date().toISOString();
+    const exitCode = code ?? undefined;
+    const failed = signal != null || (code != null && code !== 0);
+    await updateRun(runId, {
+      state: failed ? "failed" : "exited",
+      exitCode,
+      endedAt,
+    });
+    if (process.platform === "win32" && failed) {
+      // Keep window open on failure so the user can read errors.
+      return;
+    }
+    process.exit(code ?? 1);
+  })();
+});
+
+child.on("error", (error) => {
+  console.error(error);
+  void updateRun(runId, {
+    state: "failed",
+    endedAt: new Date().toISOString(),
+  }).finally(() => process.exit(1));
+});

package/src/sdk/launch/terminal.ts

@@ -0,0 +1,75 @@
+import { spawn } from "node:child_process";
+import type { LaunchPlan } from "./types";
+import { openWindowsTerminal, writeLaunchCmd } from "./windows";
+
+export type TerminalLaunch = {
+  plan: LaunchPlan;
+  runId: string;
+  runnerScript: string;
+  launchCmdPath: string;
+};
+
+export async function openInNewTerminal(inv: TerminalLaunch): Promise<void> {
+  const { plan, runId, runnerScript } = inv;
+  const platform = process.platform;
+
+  if (platform === "win32") {
+    await openInNewTerminalWindows(inv);
+    return;
+  }
+
+  const bunExe = process.execPath;
+  const shellLine = `${bunExe} ${quoteUnix(runnerScript)} ${runId}`;
+
+  if (platform === "darwin") {
+    const script = `tell application "Terminal" to do script "cd ${escapeApple(plan.cwd)} && ${escapeApple(shellLine)}"`;
+    const proc = spawn("osascript", ["-e", script], { detached: true, stdio: "ignore" });
+    proc.unref();
+    return;
+  }
+
+  const shellCmd = `cd ${quoteUnix(plan.cwd)} && ${shellLine}`;
+  const candidates = [
+    ["gnome-terminal", ["--", "bash", "-lc", shellCmd]],
+    ["konsole", ["-e", "bash", "-lc", shellCmd]],
+    ["xterm", ["-e", "bash", "-lc", shellCmd]],
+  ] as const;
+
+  for (const [bin, args] of candidates) {
+    try {
+      const proc = spawn(bin, [...args], { detached: true, stdio: "ignore" });
+      proc.unref();
+      return;
+    } catch {
+      continue;
+    }
+  }
+
+  throw new Error("No supported terminal emulator found (try Windows Terminal, Terminal.app, or gnome-terminal)");
+}
+
+async function openInNewTerminalWindows(inv: TerminalLaunch): Promise<void> {
+  const launchCmdPath = inv.launchCmdPath;
+  await writeLaunchCmd({
+    launchCmdPath,
+    bunExe: process.execPath,
+    runnerScript: inv.runnerScript,
+    runId: inv.runId,
+    cwd: inv.plan.cwd,
+  });
+
+  await openWindowsTerminal({
+    plan: inv.plan,
+    runId: inv.runId,
+    runnerScript: inv.runnerScript,
+    launchCmdPath,
+  });
+}
+
+function quoteUnix(value: string): string {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+
+function escapeApple(value: string): string {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}

package/src/sdk/launch/types.ts

@@ -0,0 +1,7 @@
+export type LaunchPlan = {
+  command: string;
+  args: string[];
+  cwd: string;
+  env: Record<string, string>;
+  title: string;
+};

package/src/sdk/launch/windows.ts

@@ -0,0 +1,109 @@
+import { spawn } from "node:child_process";
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import type { LaunchPlan } from "./types";
+
+export type WindowsLaunch = {
+  plan: LaunchPlan;
+  runId: string;
+  runnerScript: string;
+  launchCmdPath: string;
+};
+
+/** Escape a value for a line inside a .cmd file. */
+function quoteBatch(value: string): string {
+  return `"${value.replace(/"/g, '""')}"`;
+}
+
+/** Write launch.cmd with fully quoted paths (safe for spaces). */
+export async function writeLaunchCmd(input: {
+  launchCmdPath: string;
+  bunExe: string;
+  runnerScript: string;
+  runId: string;
+  cwd: string;
+}): Promise<void> {
+  const lines = [
+    "@echo off",
+    "setlocal",
+    `cd /d ${quoteBatch(input.cwd)}`,
+    `${quoteBatch(input.bunExe)} ${quoteBatch(input.runnerScript)} ${input.runId}`,
+    "set EXITCODE=%ERRORLEVEL%",
+    "if %EXITCODE% neq 0 (",
+    "  echo.",
+    "  echo Orkestrate session failed with exit code %EXITCODE%.",
+    "  pause",
+    ")",
+    "endlocal",
+    "exit /b %EXITCODE%",
+    "",
+  ];
+  await mkdir(dirname(input.launchCmdPath), { recursive: true });
+  await writeFile(input.launchCmdPath, lines.join("\r\n"), "utf-8");
+}
+
+function spawnDetached(command: string, args: string[]): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true,
+    });
+
+    child.once("error", reject);
+    child.once("spawn", () => {
+      child.unref();
+      resolve();
+    });
+  });
+}
+
+/** Prefer direct executable args; fall back to launch.cmd. */
+export async function openWindowsTerminal(inv: WindowsLaunch): Promise<void> {
+  const { plan, runId, runnerScript, launchCmdPath } = inv;
+  const bunExe = process.execPath;
+
+  const wtArgsDirect = [
+    "-w",
+    "-1",
+    "nt",
+    "-d",
+    plan.cwd,
+    "--title",
+    plan.title,
+    bunExe,
+    runnerScript,
+    runId,
+  ];
+
+  try {
+    await spawnDetached("wt.exe", wtArgsDirect);
+    return;
+  } catch {
+    // wt missing or failed — try batch launcher
+  }
+
+  const wtArgsBatch = [
+    "-w",
+    "-1",
+    "nt",
+    "-d",
+    plan.cwd,
+    "--title",
+    plan.title,
+    "cmd.exe",
+    "/d",
+    "/c",
+    launchCmdPath,
+  ];
+
+  try {
+    await spawnDetached("wt.exe", wtArgsBatch);
+    return;
+  } catch {
+    // fall through
+  }
+
+  // Last resort: new console via cmd start + launch.cmd
+  await spawnDetached("cmd.exe", ["/c", "start", plan.title, "cmd.exe", "/k", launchCmdPath]);
+}