@jmoyers/harness 0.1.10 → 0.1.20

package/scripts/control-plane-daemon.ts

@@ -72,7 +72,7 @@ function parseArgs(argv: string[], invocationDirectory: string): DaemonOptions {
   const defaultAuthToken = process.env.HARNESS_CONTROL_PLANE_AUTH_TOKEN ?? null;
   const defaultStateDbPath = resolveHarnessRuntimePath(
     invocationDirectory,
-    process.env.HARNESS_CONTROL_PLANE_DB_PATH ?? '.harness/control-plane.sqlite',
+    '.harness/control-plane.sqlite',
   );
 
   let host = defaultHost;
@@ -117,7 +117,7 @@ function parseArgs(argv: string[], invocationDirectory: string): DaemonOptions {
       if (value === undefined) {
         throw new Error('missing value for --state-db-path');
       }
-      stateDbPath = value;
+      stateDbPath = resolveHarnessRuntimePath(invocationDirectory, value);
       idx += 1;
       continue;
     }
@@ -132,6 +132,17 @@ function parseArgs(argv: string[], invocationDirectory: string): DaemonOptions {
   if (!loopbackHosts.has(host) && authToken === null) {
     throw new Error('non-loopback hosts require --auth-token or HARNESS_CONTROL_PLANE_AUTH_TOKEN');
   }
+  const workspaceRuntimeRoot = resolveHarnessWorkspaceDirectory(invocationDirectory, process.env);
+  const normalizedRuntimeRoot = resolve(workspaceRuntimeRoot);
+  const normalizedStateDbPath = resolve(stateDbPath);
+  if (
+    normalizedStateDbPath !== normalizedRuntimeRoot &&
+    !normalizedStateDbPath.startsWith(`${normalizedRuntimeRoot}/`)
+  ) {
+    throw new Error(
+      `invalid --state-db-path: ${stateDbPath}. state db path must be under workspace runtime root ${workspaceRuntimeRoot}`,
+    );
+  }
 
   return {
     host,
@@ -220,7 +231,18 @@ async function main(): Promise<number> {
       branchStrategy: loadedConfig.config.github.branchStrategy,
       viewerLogin: loadedConfig.config.github.viewerLogin,
     },
+    linear: {
+      enabled: loadedConfig.config.linear.enabled,
+      apiBaseUrl: loadedConfig.config.linear.apiBaseUrl,
+      tokenEnvVar: loadedConfig.config.linear.tokenEnvVar,
+    },
     lifecycleHooks: loadedConfig.config.hooks.lifecycle,
+    storageLifecyclePolicy: loadedConfig.config.storage.lifecycle,
+    storageLifecyclePolicyReload: {
+      cwd: invocationDirectory,
+      filePath: configPath,
+      env: process.env,
+    },
     startSession: (input) => {
       const sessionOptions: Parameters<typeof startCodexLiveSession>[0] = {
         args: input.args,

package/scripts/harness-bin.js

@@ -67,8 +67,13 @@ if (!ensureBunAvailable({ command: bunCommand })) {
 const here = dirname(fileURLToPath(import.meta.url));
 const scriptPath = resolve(here, './harness.ts');
 const runtimeArgs = [scriptPath, ...process.argv.slice(2)];
+const runtimeEnv = {
+  ...process.env,
+  HARNESS_INVOKE_CWD: process.cwd(),
+};
 const child = spawn(bunCommand, runtimeArgs, {
   stdio: 'inherit',
+  env: runtimeEnv,
 });
 
 child.once('exit', (code, signal) => {

package/scripts/harness-commands.ts

@@ -0,0 +1,300 @@
+import { Command, Flags } from '@oclif/core';
+import {
+  parseSessionName,
+  runAnimateCli,
+  runAuthCli,
+  runClientCli,
+  runCursorHooksCli,
+  runDiffCli,
+  runGatewayCli,
+  runNimCli,
+  runProfileCli,
+  runRenderTraceCli,
+  runStatusTimelineCli,
+  runUpdateCli,
+} from './harness-runtime.ts';
+
+const sessionFlag = Flags.string({
+  description:
+    'Session namespace used to isolate gateway record/log/db/profile/status-trace artifacts.',
+});
+
+interface SessionParseResult {
+  sessionName: string | null;
+  argv: readonly string[];
+}
+
+abstract class HarnessCommandBase extends Command {
+  static override strict = false;
+
+  protected extractSessionArg(argv: readonly string[]): SessionParseResult {
+    const passthrough: string[] = [];
+    let sessionName: string | null = null;
+
+    for (let index = 0; index < argv.length; index += 1) {
+      const arg = argv[index]!;
+      if (arg === '--session') {
+        const value = argv[index + 1];
+        if (value === undefined) {
+          throw new Error('missing value for --session');
+        }
+        sessionName = parseSessionName(value);
+        index += 1;
+        continue;
+      }
+      passthrough.push(arg);
+    }
+
+    return {
+      sessionName,
+      argv: passthrough,
+    };
+  }
+
+  protected exitIfNeeded(code: number): void {
+    if (code !== 0) {
+      this.exit(code);
+    }
+  }
+}
+
+class ClientCommand extends HarnessCommandBase {
+  static override summary = 'Launch the mux client (default when no explicit command is provided).';
+
+  static override usage = [
+    '[--session <name>] [mux-args...]',
+    'client [--session <name>] [mux-args...]',
+  ];
+
+  static override flags = {
+    help: Flags.help({ char: 'h' }),
+    session: sessionFlag,
+  };
+
+  override async run(): Promise<void> {
+    const parsed = this.extractSessionArg(this.argv);
+    const code = await runClientCli(parsed.argv, parsed.sessionName);
+    this.exitIfNeeded(code);
+  }
+}
+
+class GatewayCommand extends HarnessCommandBase {
+  static override summary = 'Manage the control-plane gateway lifecycle and direct command calls.';
+
+  static override usage = [
+    'gateway [--session <name>] start [--host <host>] [--port <port>] [--auth-token <token>] [--state-db-path <path>]',
+    'gateway [--session <name>] run [--host <host>] [--port <port>] [--auth-token <token>] [--state-db-path <path>]',
+    'gateway [--session <name>] stop [--force] [--timeout-ms <ms>] [--cleanup-orphans|--no-cleanup-orphans]',
+    'gateway [--session <name>] status',
+    'gateway [--session <name>] restart [--host <host>] [--port <port>] [--auth-token <token>] [--state-db-path <path>]',
+    'gateway [--session <name>] call --json \'{"type":"session.list"}\'',
+    'gateway [--session <name>] gc [--older-than-days <days>]',
+  ];
+
+  static override flags = {
+    help: Flags.help({ char: 'h' }),
+    session: sessionFlag,
+  };
+
+  override async run(): Promise<void> {
+    const parsed = this.extractSessionArg(this.argv);
+    if (parsed.argv.length === 0) {
+      this.error('missing gateway subcommand', { exit: 2 });
+    }
+    const code = await runGatewayCli(parsed.argv, parsed.sessionName);
+    this.exitIfNeeded(code);
+  }
+}
+
+class ProfileCommand extends HarnessCommandBase {
+  static override summary =
+    'Manage gateway/client CPU profiling and live inspector profiling sessions.';
+
+  static override usage = [
+    'profile [--session <name>] start [--profile-dir <path>]',
+    'profile [--session <name>] stop [--timeout-ms <ms>]',
+    'profile [--session <name>] run [--profile-dir <path>] [mux-args...]',
+    'profile [--session <name>] [--profile-dir <path>] [mux-args...]',
+  ];
+
+  static override flags = {
+    help: Flags.help({ char: 'h' }),
+    session: sessionFlag,
+  };
+
+  override async run(): Promise<void> {
+    const parsed = this.extractSessionArg(this.argv);
+    const code = await runProfileCli(parsed.argv, parsed.sessionName);
+    this.exitIfNeeded(code);
+  }
+}
+
+class StatusTimelineCommand extends HarnessCommandBase {
+  static override summary = 'Start or stop writing status timeline artifacts for a session.';
+
+  static override usage = [
+    'status-timeline [--session <name>] start [--output-path <path>]',
+    'status-timeline [--session <name>] stop',
+    'status-timeline [--session <name>] [--output-path <path>]',
+  ];
+
+  static override flags = {
+    help: Flags.help({ char: 'h' }),
+    session: sessionFlag,
+  };
+
+  override async run(): Promise<void> {
+    const parsed = this.extractSessionArg(this.argv);
+    const code = await runStatusTimelineCli(parsed.argv, parsed.sessionName);
+    this.exitIfNeeded(code);
+  }
+}
+
+class RenderTraceCommand extends HarnessCommandBase {
+  static override summary = 'Start or stop render trace recording for a session.';
+
+  static override usage = [
+    'render-trace [--session <name>] start [--output-path <path>] [--conversation-id <id>]',
+    'render-trace [--session <name>] stop',
+    'render-trace [--session <name>] [--output-path <path>] [--conversation-id <id>]',
+  ];
+
+  static override flags = {
+    help: Flags.help({ char: 'h' }),
+    session: sessionFlag,
+  };
+
+  override async run(): Promise<void> {
+    const parsed = this.extractSessionArg(this.argv);
+    const code = await runRenderTraceCli(parsed.argv, parsed.sessionName);
+    this.exitIfNeeded(code);
+  }
+}
+
+class AuthCommand extends HarnessCommandBase {
+  static override summary = 'Authenticate providers and manage saved credential state.';
+
+  static override usage = [
+    'auth login <github|linear> [--no-browser] [--timeout-ms <ms>] [--scopes <list>] [--callback-port <port>]',
+    'auth logout <github|linear|all>',
+    'auth status [--json]',
+  ];
+
+  static override flags = {
+    help: Flags.help({ char: 'h' }),
+    session: sessionFlag,
+  };
+
+  override async run(): Promise<void> {
+    const parsed = this.extractSessionArg(this.argv);
+    const code = await runAuthCli(parsed.argv, parsed.sessionName);
+    this.exitIfNeeded(code);
+  }
+}
+
+class UpdateCommand extends HarnessCommandBase {
+  static override summary = 'Install the latest Harness package globally using Bun.';
+
+  static override aliases = ['upgrade'];
+
+  static override usage = ['update', 'upgrade'];
+
+  static override flags = {
+    help: Flags.help({ char: 'h' }),
+    session: sessionFlag,
+  };
+
+  override async run(): Promise<void> {
+    const parsed = this.extractSessionArg(this.argv);
+    const code = runUpdateCli(parsed.argv, parsed.sessionName);
+    this.exitIfNeeded(code);
+  }
+}
+
+class CursorHooksCommand extends HarnessCommandBase {
+  static override summary = 'Install or uninstall managed Cursor hooks.';
+
+  static override usage = [
+    'cursor-hooks [--session <name>] install [--hooks-file <path>]',
+    'cursor-hooks [--session <name>] uninstall [--hooks-file <path>]',
+  ];
+
+  static override flags = {
+    help: Flags.help({ char: 'h' }),
+    session: sessionFlag,
+  };
+
+  override async run(): Promise<void> {
+    const parsed = this.extractSessionArg(this.argv);
+    const code = await runCursorHooksCli(parsed.argv, parsed.sessionName);
+    this.exitIfNeeded(code);
+  }
+}
+
+class AnimateCommand extends HarnessCommandBase {
+  static override summary = 'Render the terminal animation benchmark scene.';
+
+  static override usage = [
+    'animate [--fps <fps>] [--frames <count>] [--duration-ms <ms>] [--seed <seed>] [--no-color]',
+  ];
+
+  static override flags = {
+    help: Flags.help({ char: 'h' }),
+    session: sessionFlag,
+  };
+
+  override async run(): Promise<void> {
+    const parsed = this.extractSessionArg(this.argv);
+    const code = await runAnimateCli(parsed.argv);
+    this.exitIfNeeded(code);
+  }
+}
+
+class NimCommand extends HarnessCommandBase {
+  static override summary = 'Run Nim interactive TUI smoke/debug client.';
+
+  static override usage = ['nim [options]'];
+
+  static override flags = {
+    help: Flags.help({ char: 'h' }),
+    session: sessionFlag,
+  };
+
+  override async run(): Promise<void> {
+    const parsed = this.extractSessionArg(this.argv);
+    const code = await runNimCli(parsed.argv, parsed.sessionName);
+    this.exitIfNeeded(code);
+  }
+}
+
+class DiffCommand extends HarnessCommandBase {
+  static override summary = 'Render git diffs in the diff TUI/CLI view.';
+
+  static override usage = ['diff [--session <name>] [diff-options...]'];
+
+  static override flags = {
+    session: sessionFlag,
+  };
+
+  override async run(): Promise<void> {
+    const parsed = this.extractSessionArg(this.argv);
+    const code = await runDiffCli(parsed.argv, parsed.sessionName);
+    this.exitIfNeeded(code);
+  }
+}
+
+const commands = {
+  client: ClientCommand,
+  gateway: GatewayCommand,
+  profile: ProfileCommand,
+  'status-timeline': StatusTimelineCommand,
+  'render-trace': RenderTraceCommand,
+  auth: AuthCommand,
+  update: UpdateCommand,
+  'cursor-hooks': CursorHooksCommand,
+  nim: NimCommand,
+  animate: AnimateCommand,
+  diff: DiffCommand,
+} satisfies Record<string, Command.Class>;
+
+export default commands;

package/scripts/harness-runtime.ts

@@ -0,0 +1,82 @@
+import { runHarnessAnimate } from './harness-animate.ts';
+import { runNimTuiSmoke } from './nim-tui-smoke.ts';
+import {
+  createDefaultHarnessRuntimeApplication,
+  type HarnessRuntimeApplication,
+} from '../src/cli/runtime-app/application.ts';
+import { parseGlobalCliOptions, parseSessionName } from '../src/cli/parsing/session.ts';
+
+const app: HarnessRuntimeApplication = createDefaultHarnessRuntimeApplication();
+
+export { parseGlobalCliOptions, parseSessionName };
+
+export async function runGatewayCli(
+  args: readonly string[],
+  sessionName: string | null,
+): Promise<number> {
+  return await app.runGatewayCli(args, sessionName);
+}
+
+export async function runProfileCli(
+  args: readonly string[],
+  sessionName: string | null,
+): Promise<number> {
+  return await app.runProfileCli(args, sessionName);
+}
+
+export async function runStatusTimelineCli(
+  args: readonly string[],
+  sessionName: string | null,
+): Promise<number> {
+  return await app.runStatusTimelineCli(args, sessionName);
+}
+
+export async function runRenderTraceCli(
+  args: readonly string[],
+  sessionName: string | null,
+): Promise<number> {
+  return await app.runRenderTraceCli(args, sessionName);
+}
+
+export async function runAuthCli(
+  args: readonly string[],
+  sessionName: string | null,
+): Promise<number> {
+  return await app.runAuthCli(args, sessionName);
+}
+
+export function runUpdateCli(args: readonly string[], sessionName: string | null): number {
+  return app.runUpdateCli(args, sessionName);
+}
+
+export async function runCursorHooksCli(
+  args: readonly string[],
+  sessionName: string | null,
+): Promise<number> {
+  return await app.runCursorHooksCli(args, sessionName);
+}
+
+export async function runDiffCli(
+  args: readonly string[],
+  sessionName: string | null,
+): Promise<number> {
+  return await app.runDiffCli(args, sessionName);
+}
+
+export async function runClientCli(
+  args: readonly string[],
+  sessionName: string | null,
+): Promise<number> {
+  return await app.runClientCli(args, sessionName);
+}
+
+export async function runAnimateCli(args: readonly string[]): Promise<number> {
+  return await runHarnessAnimate(args);
+}
+
+export async function runNimCli(
+  args: readonly string[],
+  sessionName: string | null,
+): Promise<number> {
+  return await runNimTuiSmoke(args, { sessionName });
+}