@kal-elsam/kairo-runtime 0.2.0 → 0.2.2

package/src/global/ink/orchestrator-state.js

@@ -1,5 +1,6 @@
 import { stdin as input, stdout as output } from "node:process";
 import { canUseSetupInk } from "./terminal.js";
+import { isActiveRunState, formatTaskLabel } from "../runtime/run-types.js";
 
 export function canUseOrchestratorShell({
   interactive = Boolean(input.isTTY && output.isTTY),
@@ -12,96 +13,268 @@ export function canUseOrchestratorShell({
 
 export const ORCHESTRATOR_VIEWS = {
   HOME: "home",
-  AGENTS: "agents",
-  PROFILE: "profile",
-  PLAN: "plan",
-  CONFIRM: "confirm",
-  HELP: "help",
-  INTELLIGENCE: "intelligence"
+  ACTIVE_RUNS: "active-runs",
+  RECENT_RUNS: "recent-runs",
+  RUN_DETAIL: "run-detail",
+  PROVIDERS: "providers",
+  LAUNCH: "launch",
+  DIAGNOSTICS: "diagnostics",
+  HELP: "help"
 };
 
 export const ORCHESTRATOR_MENU = [
-  { id: "status", label: "Diagnostics", view: ORCHESTRATOR_VIEWS.HOME },
-  { id: "agents", label: "Agents", view: ORCHESTRATOR_VIEWS.AGENTS },
-  { id: "intelligence", label: "Intelligence", view: ORCHESTRATOR_VIEWS.INTELLIGENCE },
-  { id: "profile", label: "Profile", view: ORCHESTRATOR_VIEWS.PROFILE },
-  { id: "plan-setup", label: "Plan setup", view: ORCHESTRATOR_VIEWS.PLAN, action: "setup" },
+  { id: "active", label: "Active runs", view: ORCHESTRATOR_VIEWS.ACTIVE_RUNS },
+  { id: "recent", label: "Recent runs", view: ORCHESTRATOR_VIEWS.RECENT_RUNS },
+  { id: "providers", label: "Providers", view: ORCHESTRATOR_VIEWS.PROVIDERS },
+  { id: "launch", label: "Launch run", view: ORCHESTRATOR_VIEWS.LAUNCH, action: "launch" },
+  { id: "diagnostics", label: "Diagnostics", view: ORCHESTRATOR_VIEWS.DIAGNOSTICS },
   { id: "help", label: "Help", view: ORCHESTRATOR_VIEWS.HELP }
 ];
 
-export function formatAgentStatusLines(capabilities) {
-  return capabilities.map((entry) => {
-    const auth = entry.authenticated == null ? "n/a" : (entry.authenticated ? "yes" : "no");
-    const version = entry.version ?? "unknown";
-    return `${entry.label.padEnd(14)} ${entry.state.padEnd(14)} v${version} auth=${auth}`;
-  });
+export const LAUNCH_WIZARD_STEPS = {
+  AGENT: "agent",
+  TASK: "task",
+  MODEL: "model",
+  PERMISSIONS: "permissions",
+  CONFIRM: "confirm"
+};
+
+export const LAUNCH_PERMISSION_OPTIONS = [
+  { id: "default", label: "Default (agent prompts)", permissions: [] },
+  { id: "force", label: "Force / auto-approve", permissions: ["force"] },
+  { id: "yolo", label: "YOLO / skip permissions", permissions: ["yolo"] }
+];
+
+export function resolveLaunchableAgents(providers = []) {
+  return providers
+    .filter((provider) => provider.launchable)
+    .map((provider) => provider.id);
 }
 
-export function formatProfileLines(profileJson) {
-  const lines = [
-    `Coordinator: ${profileJson.coordinator ?? "none"}`,
-    `Default agents: ${formatAgentsLabel(profileJson.defaultAgents)}`,
-    `Apply mode: ${profileJson.applyMode}`,
-    `Preferred backend: ${profileJson.preferredBackend ?? "auto"}`,
-    `Preferred model: ${profileJson.preferredModel ?? "auto"}`,
-    `Cloud consent preference: ${profileJson.cloudConsent ? "recorded (session --cloud-consent still required)" : "no"}`,
-    `Token budget: ${profileJson.tokenBudget ?? "none"}`
-  ];
+export function createLaunchDraft() {
+  return {
+    agentId: null,
+    task: "",
+    model: "",
+    permissionIndex: 0
+  };
+}
+
+export function resolveLaunchPermissions(draft) {
+  return LAUNCH_PERMISSION_OPTIONS[draft.permissionIndex]?.permissions ?? [];
+}
+
+export function advanceLaunchWizardStep(currentStep) {
+  switch (currentStep) {
+    case LAUNCH_WIZARD_STEPS.AGENT:
+      return LAUNCH_WIZARD_STEPS.TASK;
+    case LAUNCH_WIZARD_STEPS.TASK:
+      return LAUNCH_WIZARD_STEPS.MODEL;
+    case LAUNCH_WIZARD_STEPS.MODEL:
+      return LAUNCH_WIZARD_STEPS.PERMISSIONS;
+    case LAUNCH_WIZARD_STEPS.PERMISSIONS:
+      return LAUNCH_WIZARD_STEPS.CONFIRM;
+    default:
+      return LAUNCH_WIZARD_STEPS.CONFIRM;
+  }
+}
 
-  if (profileJson.sources.global) {
-    lines.push(`Global: ${profileJson.sources.global}`);
+export function retreatLaunchWizardStep(currentStep) {
+  switch (currentStep) {
+    case LAUNCH_WIZARD_STEPS.CONFIRM:
+      return LAUNCH_WIZARD_STEPS.PERMISSIONS;
+    case LAUNCH_WIZARD_STEPS.PERMISSIONS:
+      return LAUNCH_WIZARD_STEPS.MODEL;
+    case LAUNCH_WIZARD_STEPS.MODEL:
+      return LAUNCH_WIZARD_STEPS.TASK;
+    case LAUNCH_WIZARD_STEPS.TASK:
+      return LAUNCH_WIZARD_STEPS.AGENT;
+    default:
+      return LAUNCH_WIZARD_STEPS.AGENT;
   }
+}
+
+export function formatLaunchWizardLines({
+  step,
+  draft,
+  launchableAgents,
+  agentIndex,
+  permissionIndex
+}) {
+  const lines = [`Step: ${step}`];
 
-  if (profileJson.sources.project) {
-    lines.push(`Project: ${profileJson.sources.project}`);
+  if (step === LAUNCH_WIZARD_STEPS.AGENT) {
+    lines.push("Select agent:");
+    for (const [index, agentId] of launchableAgents.entries()) {
+      const marker = index === agentIndex ? "›" : " ";
+      lines.push(`${marker} ${agentId}`);
+    }
+    return lines;
   }
 
-  lines.push(`Precedence: ${profileJson.sources.precedence}`);
+  if (step === LAUNCH_WIZARD_STEPS.TASK) {
+    lines.push(`Agent: ${draft.agentId ?? "—"}`);
+    lines.push(`Task: ${draft.task || "(type your task)"}`);
+    lines.push("Enter to continue · Backspace to edit");
+    return lines;
+  }
+
+  if (step === LAUNCH_WIZARD_STEPS.MODEL) {
+    lines.push(`Agent: ${draft.agentId ?? "—"}`);
+    lines.push(`Task length: ${draft.task.length} chars`);
+    lines.push(`Model: ${draft.model || "(default — press Enter)"}`);
+    lines.push("Type model alias or Enter for default");
+    return lines;
+  }
+
+  if (step === LAUNCH_WIZARD_STEPS.PERMISSIONS) {
+    lines.push("Permissions:");
+    for (const [index, option] of LAUNCH_PERMISSION_OPTIONS.entries()) {
+      const marker = index === permissionIndex ? "›" : " ";
+      lines.push(`${marker} ${option.label}`);
+    }
+    return lines;
+  }
+
+  lines.push(`Agent: ${draft.agentId ?? "—"}`);
+  lines.push(`Task length: ${draft.task.length} chars (content not stored)`);
+  lines.push(`Model: ${draft.model || "default"}`);
+  lines.push(`Permissions: ${LAUNCH_PERMISSION_OPTIONS[permissionIndex]?.label ?? "default"}`);
+  lines.push("Enter to launch · Esc to go back");
   return lines;
 }
 
-export function formatIntelligenceLines(diagnostics) {
-  const intelligence = diagnostics?.intelligence;
-  if (!intelligence) {
-    return ["Intelligence layer unavailable."];
-  }
+export function resolveMenuItem(menuIndex) {
+  return ORCHESTRATOR_MENU[menuIndex] ?? null;
+}
+
+export function resolveMenuItemView(menuIndex) {
+  return resolveMenuItem(menuIndex)?.view ?? ORCHESTRATOR_VIEWS.HOME;
+}
+
+export function shiftMenuIndex(currentIndex, direction, menuLength = ORCHESTRATOR_MENU.length) {
+  const delta = direction === "up" ? -1 : direction === "down" ? 1 : 0;
+  return Math.min(menuLength - 1, Math.max(0, currentIndex + delta));
+}
 
+export function formatRunLines(runs, { emptyMessage = "No runs." } = {}) {
+  if (!runs || runs.length === 0) return [emptyMessage];
+
+  return runs.map((run) => {
+    const state = run.state.padEnd(12);
+    const agent = run.agentId.padEnd(10);
+    return `${run.runId}  ${state}  ${agent}  ${formatTaskLabel(run)}`;
+  });
+}
+
+export function formatProviderLines(providers) {
+  return providers.map((provider) => {
+    const status = provider.launchable
+      ? "launchable"
+      : provider.compatible
+        ? "auditable"
+        : provider.available
+          ? "limited"
+          : "missing";
+    return `${provider.label.padEnd(14)} ${status.padEnd(12)} ${provider.reason ?? ""}`.trimEnd();
+  });
+}
+
+export function formatDiagnosticsLines(diagnostics) {
+  const summary = diagnostics?.diagnostics;
   const lines = [
-    `Local available: ${intelligence.summary.localAvailable ? "yes" : "no"}`,
-    `Cloud authenticated: ${intelligence.summary.cloudAuthenticated ? "yes" : "no"}`,
-    `Routing: ${intelligence.routingPreview?.reason ?? "n/a"}`,
-    `Can invoke: ${intelligence.routingPreview?.canInvoke ? "yes" : "no"}`,
-    ""
+    "Summary",
+    `CLI version: ${diagnostics?.cliVersion ?? "unknown"}`,
+    `Agents detected: ${summary?.detected ?? 0}/${diagnostics?.capabilities?.length ?? 0}`,
+    `Available: ${summary?.available ?? 0}`,
+    `Unknown: ${summary?.unknown ?? 0}`,
+    `Errors: ${summary?.errors ?? 0}`,
+    "",
+    "Agent capabilities",
+    ...formatAgentStatusLines(diagnostics?.capabilities ?? [])
   ];
 
-  for (const backend of intelligence.backends ?? []) {
-    lines.push(
-      `${backend.label.padEnd(14)} ${backend.state.padEnd(14)} models=${backend.models?.length ?? 0}`
-    );
+  const recommendations = diagnostics?.recommendations ?? [];
+  if (recommendations.length > 0) {
+    lines.push("", "Recommendations");
+    for (const recommendation of recommendations) {
+      lines.push(`  • ${recommendation}`);
+    }
   }
 
   return lines;
 }
 
-export function formatPlanLines(plan) {
-  const lines = [`Action: ${plan.action}`, ""];
-  for (const step of plan.steps) {
-    lines.push(`  • ${step}`);
-  }
+export function formatAgentStatusLines(capabilities) {
+  return capabilities.map((entry) => {
+    const auth = entry.authenticated == null ? "n/a" : (entry.authenticated ? "yes" : "no");
+    const version = entry.version ?? "unknown";
+    return `${entry.label.padEnd(14)} ${entry.state.padEnd(14)} v${version} auth=${auth}`;
+  });
+}
+
+export function formatRunDetailLines(run, events = []) {
+  if (!run) return ["Run not found."];
 
-  if (plan.warnings.length > 0) {
-    lines.push("", "Warnings:");
-    for (const warning of plan.warnings) {
-      lines.push(`  ! ${warning}`);
+  const lines = [
+    `Run: ${run.runId}`,
+    `Agent: ${run.agentId} (${run.provider})`,
+    `State: ${run.state}`,
+    `Model: ${run.model ?? "default"}`,
+    `Cwd: ${run.cwd}`,
+    `Started: ${run.startedAt}`,
+    `Updated: ${run.updatedAt}`
+  ];
+
+  if (run.completedAt) lines.push(`Completed: ${run.completedAt}`);
+  if (run.tokenUsage) lines.push(`Tokens: ${JSON.stringify(run.tokenUsage)}`);
+  if (run.error) lines.push(`Error: ${run.error}`);
+  if (run.tools?.length) lines.push(`Tools: ${run.tools.join(", ")}`);
+
+  if (events.length > 0) {
+    lines.push("", "Recent events");
+    for (const event of events.slice(-8)) {
+      if (event.parseError) continue;
+      lines.push(`  ${event.type}  ${summarizeEvent(event)}`);
     }
   }
 
   return lines;
 }
 
-function formatAgentsLabel(agents) {
-  if (agents === "detected") return "detected";
-  if (agents === "all") return "all";
-  if (Array.isArray(agents)) return agents.join(", ");
-  return String(agents);
+export function formatDashboardSnapshot(dashboard) {
+  const active = dashboard?.activeRuns?.length ?? 0;
+  const recent = dashboard?.recentRuns?.length ?? 0;
+  const auditable = (dashboard?.providers ?? []).filter((entry) => entry.compatible).length;
+  return [
+    `Active runs: ${active}`,
+    `Recent runs: ${recent}`,
+    `Auditable providers: ${auditable}/${dashboard?.providers?.length ?? 0}`
+  ];
+}
+
+export function selectRunFromList(runs, index) {
+  return runs[index] ?? null;
+}
+
+export function filterInspectableRuns(runs) {
+  return runs ?? [];
+}
+
+export function isRunCancellable(run) {
+  return run && isActiveRunState(run.state);
+}
+
+function summarizeEvent(event) {
+  if (event.type === "agent.tool_call") {
+    return event.data?.tool_name ?? event.data?.name ?? "tool";
+  }
+  if (event.type === "process.stdout" || event.type === "process.stderr") {
+    const line = event.data?.line ?? "";
+    return line.length > 60 ? `${line.slice(0, 59)}…` : line;
+  }
+  if (event.type === "run.completed" || event.type === "run.failed") {
+    return `exit=${event.data?.exitCode ?? "n/a"}`;
+  }
+  return "";
 }

package/src/global/orchestrator.js

@@ -1,11 +1,10 @@
 import { stdin as input, stdout as output } from "node:process";
 import { resolveHomeDir } from "./paths.js";
-import { runGlobalSetup } from "./global-cli.js";
-import { PLAN_ACTIONS, buildReadOnlyDiagnostics, shouldExecutePlan } from "./action-planner.js";
 import { canUseOrchestratorShell } from "./ink/orchestrator-state.js";
 import { runOrchestratorInk as defaultRunOrchestratorInk } from "./ink/run-orchestrator-ink.js";
 import { formatCliCommand } from "./brand/cli.js";
 import { BRAND } from "./brand/index.js";
+import { buildReadOnlyDiagnostics, shouldExecutePlan } from "./action-planner.js";
 
 export { canUseOrchestratorShell };
 
@@ -28,13 +27,13 @@ export async function runOrchestratorShell({
 }) {
   if (!interactive) {
     throw new Error(
-      `Non-interactive shell requires an explicit command. Try ${formatCliCommand("help")} or ${formatCliCommand("setup --yes")}.`
+      `Non-interactive shell requires an explicit command. Try ${formatCliCommand("help")} or ${formatCliCommand("runs list")}.`
     );
   }
 
   if (!canUseOrchestratorShell({ interactive })) {
     throw new Error(
-      `Interactive shell requires a capable TTY. Use ${formatCliCommand("setup --simple")} or explicit commands.`
+      `Interactive shell requires a capable TTY. Use ${formatCliCommand("runs list")} or explicit commands.`
     );
   }
 
@@ -51,41 +50,11 @@ export async function runOrchestratorShell({
     throw outcome.error;
   }
 
-  if (outcome.cancelled) {
-    return { cancelled: true, wrote: false };
-  }
-
-  if (outcome.confirmed && outcome.action === PLAN_ACTIONS.SETUP) {
-    const setupOutcome = await runGlobalSetup(
-      {
-        cwd: workspaceRoot,
-        adapters: null,
-        components: null,
-        noDefaultComponents: false,
-        dryRun: false,
-        yes: false,
-        confirm: false,
-        preflight: true,
-        preflightExplicit: false,
-        yesExplicit: false,
-        confirmExplicit: false,
-        json: false,
-        interactive: true,
-        simple: false
-      },
-      packageManifest,
-      packageRoot
-    );
-
-    return {
-      cancelled: Boolean(setupOutcome.cancelled),
-      wrote: !setupOutcome.cancelled && !setupOutcome.result?.dryRun,
-      action: PLAN_ACTIONS.SETUP,
-      setupOutcome
-    };
-  }
-
-  return { cancelled: false, wrote: false, action: outcome.action ?? null };
+  return {
+    cancelled: Boolean(outcome.cancelled),
+    wrote: false,
+    action: outcome.action ?? null
+  };
 }
 
 export async function runOrchestratorDiagnostics({

package/src/global/paths.js

@@ -17,7 +17,20 @@ export function harnessHomePaths(homeDir) {
     policyPath: join(root, "policy.json"),
     profilePath: join(root, "profile.json"),
     historyPath: join(root, "history.jsonl"),
+    runsDir: join(root, "runs"),
     coreDir: join(root, "core"),
     backupsDir: join(root, "backups")
   };
 }
+
+export function runPaths(homeDir, runId) {
+  const { runsDir } = harnessHomePaths(homeDir);
+  const runDir = join(runsDir, runId);
+
+  return {
+    runDir,
+    statePath: join(runDir, "state.json"),
+    eventsPath: join(runDir, "events.jsonl"),
+    transcriptPath: join(runDir, "transcript.jsonl")
+  };
+}

package/src/global/profile.js

@@ -4,6 +4,7 @@ import { join } from "node:path";
 import { harnessHomePaths } from "./paths.js";
 import { AGENT_CAPABILITY_IDS } from "./agent-capabilities/index.js";
 import { classifyCustomBaseUrl, isValidEnvironmentName } from "./intelligence/custom-url.js";
+import { validateRuntimeProfile, RUNTIME_PROFILE_KEYS } from "./runtime/run-profile.js";
 
 export const PROFILE_KEYS = new Set([
   "coordinator",
@@ -16,7 +17,8 @@ export const PROFILE_KEYS = new Set([
   "tokenBudget",
   "stableContextBudget",
   "requestContextBudget",
-  "customProviders"
+  "customProviders",
+  ...RUNTIME_PROFILE_KEYS
 ]);
 
 export const DEFAULT_PROFILE = {
@@ -30,7 +32,13 @@ export const DEFAULT_PROFILE = {
   tokenBudget: null,
   stableContextBudget: null,
   requestContextBudget: null,
-  customProviders: []
+  customProviders: [],
+  agentAliases: {},
+  modelAliases: {},
+  defaultPermissions: [],
+  defaultRuntimeAgent: null,
+  defaultRuntimeModel: null,
+  captureTranscript: false
 };
 
 const APPLY_MODES = new Set(["prompt", "confirm"]);
@@ -105,6 +113,12 @@ export function buildProfileJson(resolved) {
     stableContextBudget: profile.stableContextBudget,
     requestContextBudget: profile.requestContextBudget,
     customProviders: sanitizeCustomProviders(profile.customProviders),
+    agentAliases: profile.agentAliases ?? {},
+    modelAliases: profile.modelAliases ?? {},
+    defaultPermissions: profile.defaultPermissions ?? [],
+    defaultRuntimeAgent: profile.defaultRuntimeAgent ?? null,
+    defaultRuntimeModel: profile.defaultRuntimeModel ?? null,
+    captureTranscript: profile.captureTranscript ?? false,
     sources: {
       global: sources.global,
       project: sources.project,
@@ -187,6 +201,7 @@ function validateProfile(profile) {
 
   validateNoSecrets(profile);
   validateCustomProviders(profile.customProviders);
+  validateRuntimeProfile(profile);
 }
 
 /**

package/src/global/runtime/execution-adapters/claude.js

@@ -0,0 +1,65 @@
+import { createExecutionAdapter, parseNdjsonLine, buildPermissionsArgs } from "./create-execution-adapter.js";
+
+const EXECUTABLE = "claude";
+
+function buildClaudeLaunch({ task, cwd, model, permissions = [] }) {
+  const args = [
+    "-p",
+    "--output-format",
+    "stream-json",
+    ...buildPermissionsArgs(permissions),
+    task
+  ];
+
+  if (model) {
+    args.unshift("--model", model);
+  }
+
+  return {
+    command: EXECUTABLE,
+    args,
+    cwd,
+    env: process.env
+  };
+}
+
+function parseClaudeEventLine(line) {
+  const parsed = parseNdjsonLine(line);
+  if (!parsed || typeof parsed !== "object") return null;
+
+  if (parsed.type === "tool_use" || parsed.type === "tool_call") {
+    return {
+      type: "tool_call",
+      tool_name: parsed.name ?? parsed.tool ?? "unknown",
+      status: parsed.status ?? "started"
+    };
+  }
+
+  if (parsed.type === "usage" || parsed.usage) {
+    const usage = parsed.usage ?? parsed;
+    return {
+      type: "usage",
+      inputTokens: usage.input_tokens ?? usage.input ?? null,
+      outputTokens: usage.output_tokens ?? usage.output ?? null,
+      totalTokens: usage.total_tokens ?? usage.total ?? null,
+      cost: usage.cost ?? null
+    };
+  }
+
+  return parsed;
+}
+
+export default createExecutionAdapter({
+  id: "claude",
+  label: "Claude Code",
+  executable: EXECUTABLE,
+  capabilities: {
+    structuredEvents: true,
+    tokens: true,
+    diff: false,
+    cancel: true,
+    transcript: true
+  },
+  buildLaunch: buildClaudeLaunch,
+  parseEventLine: parseClaudeEventLine
+});

package/src/global/runtime/execution-adapters/codex.js

@@ -0,0 +1,78 @@
+import { createExecutionAdapter, parseNdjsonLine } from "./create-execution-adapter.js";
+
+const EXECUTABLE = "codex";
+
+function buildCodexPermissionsArgs(permissions = []) {
+  const normalized = new Set(permissions.map((entry) => String(entry).toLowerCase()));
+
+  if (
+    normalized.has("yolo")
+    || normalized.has("dangerously-skip-permissions")
+    || normalized.has("dangerously-bypass-approvals-and-sandbox")
+  ) {
+    return ["--dangerously-bypass-approvals-and-sandbox"];
+  }
+
+  return [];
+}
+
+function buildCodexLaunch({ task, cwd, model, permissions = [] }) {
+  const args = [
+    "exec",
+    "--json",
+    ...buildCodexPermissionsArgs(permissions),
+    task
+  ];
+
+  if (model) {
+    args.unshift("--model", model);
+  }
+
+  return {
+    command: EXECUTABLE,
+    args,
+    cwd,
+    env: process.env
+  };
+}
+
+function parseCodexEventLine(line) {
+  const parsed = parseNdjsonLine(line);
+  if (!parsed || typeof parsed !== "object") return null;
+
+  if (parsed.type === "tool" || parsed.type === "tool_call") {
+    return {
+      type: "tool_call",
+      tool_name: parsed.tool ?? parsed.name ?? "unknown",
+      status: parsed.status ?? "started"
+    };
+  }
+
+  if (parsed.usage || parsed.token_usage) {
+    const usage = parsed.usage ?? parsed.token_usage;
+    return {
+      type: "usage",
+      inputTokens: usage.input_tokens ?? usage.input ?? null,
+      outputTokens: usage.output_tokens ?? usage.output ?? null,
+      totalTokens: usage.total_tokens ?? usage.total ?? null,
+      cost: usage.cost ?? null
+    };
+  }
+
+  return parsed;
+}
+
+export default createExecutionAdapter({
+  id: "codex",
+  label: "Codex",
+  executable: EXECUTABLE,
+  capabilities: {
+    structuredEvents: true,
+    tokens: true,
+    diff: false,
+    cancel: true,
+    transcript: true
+  },
+  buildLaunch: buildCodexLaunch,
+  parseEventLine: parseCodexEventLine
+});