@jmoyers/harness 0.1.8 → 0.1.10

package/scripts/codex-live-mux-runtime.ts

@@ -93,6 +93,7 @@ import {
 import {
   normalizeGitHubRemoteUrl,
   repositoryNameFromGitHubRemoteUrl,
+  resolveGitHubTrackedBranchForActions,
   shouldShowGitHubPrActions,
 } from '../src/mux/live-mux/git-parsing.ts';
 import { readProcessUsageSample, runGitCommand } from '../src/mux/live-mux/git-snapshot.ts';
@@ -257,6 +258,13 @@ interface CommandMenuGitHubProjectPrState {
   readonly loading: boolean;
 }
 
+interface GitHubDebugAuthState {
+  enabled: boolean;
+  token: 'env' | 'gh' | 'none';
+  auth: 'ok' | 'no' | 'er' | 'na' | 'uk';
+  projectPr: 'ok' | 'er' | 'na';
+}
+
 interface ThemePickerSessionState {
   readonly initialThemeConfig: HarnessMuxThemeConfig | null;
   committed: boolean;
@@ -404,6 +412,28 @@ function commandExistsOnPath(command: string): boolean {
   }
 }
 
+function readGhAuthTokenForDebug(): string | null {
+  try {
+    const stdout = execFileSync('gh', ['auth', 'token'], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: 2000,
+      windowsHide: true,
+    });
+    const token = stdout.trim();
+    return token.length > 0 ? token : null;
+  } catch {
+    return null;
+  }
+}
+
+function formatGitHubDebugTokens(state: GitHubDebugAuthState): string {
+  if (!state.enabled) {
+    return '[gh:off tk:na au:na pr:na]';
+  }
+  return `[gh:on tk:${state.token} au:${state.auth} pr:${state.projectPr}]`;
+}
+
 async function main(): Promise<number> {
   if (!process.stdin.isTTY || !process.stdout.isTTY) {
     process.stderr.write('codex:live:mux requires a TTY stdin/stdout\n');
@@ -502,6 +532,26 @@ async function main(): Promise<number> {
   const resolvedMuxTheme = resolveAndApplyRuntimeTheme(runtimeThemeConfig, true);
   let currentModalTheme = resolvedMuxTheme.theme.modalTheme;
   const configuredMuxGit = loadedConfig.config.mux.git;
+  const githubTokenEnvVar = loadedConfig.config.github.tokenEnvVar;
+  const envGitHubTokenRaw = process.env[githubTokenEnvVar];
+  const hasEnvGitHubToken =
+    typeof envGitHubTokenRaw === 'string' && envGitHubTokenRaw.trim().length > 0;
+  const githubDebugAuthState: GitHubDebugAuthState = {
+    enabled: loadedConfig.config.github.enabled,
+    token: hasEnvGitHubToken ? 'env' : 'none',
+    auth: loadedConfig.config.github.enabled ? (hasEnvGitHubToken ? 'ok' : 'uk') : 'na',
+    projectPr: 'na',
+  };
+  if (githubDebugAuthState.enabled && !hasEnvGitHubToken) {
+    const ghToken = commandExistsOnPath('gh') ? readGhAuthTokenForDebug() : null;
+    if (ghToken !== null) {
+      githubDebugAuthState.token = 'gh';
+      githubDebugAuthState.auth = 'ok';
+    } else {
+      githubDebugAuthState.token = 'none';
+      githubDebugAuthState.auth = 'no';
+    }
+  }
   const configuredCodexLaunch = loadedConfig.config.codex.launch;
   const configuredCritique = loadedConfig.config.critique;
   const codexLaunchModeByDirectoryPath: Record<string, 'yolo' | 'standard'> = {};
@@ -1414,6 +1464,14 @@ async function main(): Promise<number> {
       commandMenuGitHubProjectPrState.directoryId === activeDirectoryId
         ? commandMenuGitHubProjectPrState
         : null;
+    const currentBranchForActions =
+      activeDirectoryId === null
+        ? null
+        : (gitSummaryByDirectoryId.get(activeDirectoryId)?.branch ?? null);
+    const trackedBranchForActions = resolveGitHubTrackedBranchForActions({
+      projectTrackedBranch: githubProjectPrState?.branchName ?? null,
+      currentBranch: currentBranchForActions,
+    });
     const selectedText =
       workspace.selection === null
         ? ''
@@ -1435,7 +1493,7 @@ async function main(): Promise<number> {
       ),
       githubRepositoryUrl: activeDirectoryRepositorySnapshot?.normalizedRemoteUrl ?? null,
       githubDefaultBranch: activeDirectoryRepositorySnapshot?.defaultBranch ?? null,
-      githubTrackedBranch: githubProjectPrState?.branchName ?? null,
+      githubTrackedBranch: trackedBranchForActions,
       githubOpenPrUrl: githubProjectPrState?.openPrUrl ?? null,
       githubProjectPrLoading: githubProjectPrState?.loading ?? false,
     };
@@ -1707,6 +1765,13 @@ async function main(): Promise<number> {
   };
   const githubAuthHintNotice =
     'GitHub PR actions become available after auth (`gh auth login` or `GITHUB_TOKEN`).';
+  const setGitHubDebugAuthState = (
+    update: Partial<Pick<GitHubDebugAuthState, 'token' | 'auth' | 'projectPr'>>,
+  ): void => {
+    githubDebugAuthState.token = update.token ?? githubDebugAuthState.token;
+    githubDebugAuthState.auth = update.auth ?? githubDebugAuthState.auth;
+    githubDebugAuthState.projectPr = update.projectPr ?? githubDebugAuthState.projectPr;
+  };
   const isGitHubAuthUnavailableError = (error: unknown): boolean => {
     const message = formatErrorMessage(error).toLowerCase();
     return (
@@ -1729,7 +1794,14 @@ async function main(): Promise<number> {
           directoryId,
         });
         commandMenuGitHubProjectPrState = parseGitHubProjectPrState(directoryId, result);
-      } catch {
+        setGitHubDebugAuthState({
+          projectPr: 'ok',
+        });
+      } catch (error: unknown) {
+        setGitHubDebugAuthState({
+          projectPr: 'er',
+          auth: isGitHubAuthUnavailableError(error) ? 'no' : githubDebugAuthState.auth,
+        });
         commandMenuGitHubProjectPrState = {
           directoryId,
           branchName: null,
@@ -2517,6 +2589,12 @@ async function main(): Promise<number> {
         },
       });
     },
+    listConversationIdsForTitleRefresh: () => conversationManager.orderedIds(),
+    conversationAgentTypeForTitleRefresh: (sessionId) =>
+      conversationManager.get(sessionId)?.agentType ?? null,
+    refreshConversationTitle: async (sessionId) => {
+      return await controlPlaneService.refreshConversationTitle(sessionId);
+    },
   });
   const runtimeWorkspaceActions = new RuntimeWorkspaceActions({
     conversationActions: conversationLifecycle,
@@ -2619,17 +2697,23 @@ async function main(): Promise<number> {
 
   const runCritiqueReviewFromCommandMenu = (
     directoryId: string,
-    mode: 'staged' | 'base-branch',
+    mode: 'unstaged' | 'staged' | 'base-branch',
   ): void => {
     queueControlPlaneOp(async () => {
       const agent = resolveCritiqueReviewAgentFromEnvironment();
-      if (mode === 'staged') {
+      if (mode !== 'base-branch') {
         const commandText = buildCritiqueReviewCommand({
-          mode: 'staged',
+          mode,
           agent,
         });
         await runCommandInNewTerminalThread(directoryId, commandText);
-        setCommandNotice(`running critique staged review (${agent ?? 'default'})`);
+        const reviewLabelByMode: Readonly<Record<'unstaged' | 'staged', string>> = {
+          unstaged: 'unstaged',
+          staged: 'staged',
+        };
+        setCommandNotice(
+          `running critique ${reviewLabelByMode[mode]} review (${agent ?? 'default'})`,
+        );
         return;
       }
       const baseBranch = await resolveCritiqueReviewBaseBranchForDirectory(directoryId);
@@ -2653,6 +2737,16 @@ async function main(): Promise<number> {
       return [];
     }
     return [
+      {
+        id: 'critique.review.unstaged',
+        title: 'Critique AI Review: Unstaged Changes',
+        aliases: ['critique unstaged review', 'review unstaged diff', 'ai review unstaged'],
+        keywords: ['critique', 'review', 'unstaged', 'diff', 'ai'],
+        detail: 'runs critique review',
+        run: () => {
+          runCritiqueReviewFromCommandMenu(directoryId, 'unstaged');
+        },
+      },
       {
         id: 'critique.review.staged',
         title: 'Critique AI Review: Staged Changes',
@@ -2906,9 +3000,17 @@ async function main(): Promise<number> {
                 });
               } catch (error: unknown) {
                 if (isGitHubAuthUnavailableError(error)) {
+                  setGitHubDebugAuthState({
+                    auth: 'no',
+                    projectPr: 'er',
+                  });
                   setCommandNotice(githubAuthHintNotice);
                   return;
                 }
+                setGitHubDebugAuthState({
+                  auth: 'er',
+                  projectPr: 'er',
+                });
                 throw error;
               }
               const parsedResult = asRecord(result);
@@ -2917,6 +3019,9 @@ async function main(): Promise<number> {
                 return;
               }
               const state = parseGitHubProjectPrState(directoryId, parsedResult);
+              setGitHubDebugAuthState({
+                projectPr: 'ok',
+              });
               commandMenuGitHubProjectPrState = state;
               if (state.openPrUrl === null) {
                 setCommandNotice('no open pull request for tracked branch');
@@ -2949,9 +3054,15 @@ async function main(): Promise<number> {
                 });
               } catch (error: unknown) {
                 if (isGitHubAuthUnavailableError(error)) {
+                  setGitHubDebugAuthState({
+                    auth: 'no',
+                  });
                   setCommandNotice(githubAuthHintNotice);
                   return;
                 }
+                setGitHubDebugAuthState({
+                  auth: 'er',
+                });
                 throw error;
               }
               const parsedResult = asRecord(result);
@@ -2963,6 +3074,10 @@ async function main(): Promise<number> {
               if (prUrl === null) {
                 throw new Error('github.pr-create returned malformed pr url');
               }
+              setGitHubDebugAuthState({
+                auth: 'ok',
+                projectPr: 'ok',
+              });
               refreshCommandMenuGitHubProjectPrState(directoryId);
               const opened = openUrlInBrowser(prUrl);
               setCommandNotice(
@@ -3071,7 +3186,8 @@ async function main(): Promise<number> {
   >({
     renderFlush: {
       perfNowNs,
-      statusFooterForConversation: (conversation) => debugFooterForConversation(conversation),
+      statusFooterForConversation: (conversation) =>
+        `${formatGitHubDebugTokens(githubDebugAuthState)} ${debugFooterForConversation(conversation)}`,
       currentStatusNotice: () => debugFooterNotice.current(),
       currentStatusRow: () => outputLoadSampler.currentStatusRow(),
       onStatusLineComposed: (input) => {

package/scripts/control-plane-daemon.ts

@@ -1,8 +1,11 @@
 import { resolve } from 'node:path';
 import { startCodexLiveSession } from '../src/codex/live-session.ts';
 import { startControlPlaneStreamServer } from '../src/control-plane/stream-server.ts';
-import { loadHarnessConfig } from '../src/config/config-core.ts';
-import { resolveHarnessRuntimePath } from '../src/config/harness-paths.ts';
+import { loadHarnessConfig, resolveHarnessConfigPath } from '../src/config/config-core.ts';
+import {
+  resolveHarnessRuntimePath,
+  resolveHarnessWorkspaceDirectory,
+} from '../src/config/harness-paths.ts';
 import { migrateLegacyHarnessLayout } from '../src/config/harness-runtime-migration.ts';
 import { loadHarnessSecrets } from '../src/config/secrets-core.ts';
 import {
@@ -140,6 +143,11 @@ function parseArgs(argv: string[], invocationDirectory: string): DaemonOptions {
 
 async function main(): Promise<number> {
   const invocationDirectory = resolveInvocationDirectory();
+  const gatewayRunIdRaw = process.env.HARNESS_GATEWAY_RUN_ID;
+  const gatewayRunId =
+    typeof gatewayRunIdRaw === 'string' && gatewayRunIdRaw.trim().length > 0
+      ? gatewayRunIdRaw.trim()
+      : `gateway-run-${process.pid}`;
   migrateLegacyHarnessLayout(invocationDirectory, process.env);
   loadHarnessSecrets({ cwd: invocationDirectory });
   configureProcessPerf(invocationDirectory);
@@ -159,14 +167,22 @@ async function main(): Promise<number> {
   }
   const startupSpan = startPerfSpan('daemon.startup.total', {
     process: 'daemon',
+    gatewayRunId,
   });
   recordPerfEvent('daemon.startup.begin', {
     process: 'daemon',
+    gatewayRunId,
   });
   const options = parseArgs(process.argv.slice(2), invocationDirectory);
+  const workspaceRuntimeRoot = resolveHarnessWorkspaceDirectory(invocationDirectory, process.env);
+  const configPath = resolveHarnessConfigPath(invocationDirectory, process.env);
+  process.stdout.write(
+    `[control-plane] boot runId=${gatewayRunId} pid=${String(process.pid)} ppid=${String(process.ppid)} workspaceRoot=${invocationDirectory} runtimeRoot=${workspaceRuntimeRoot} config=${configPath} db=${options.stateDbPath}\n`,
+  );
 
   const listenSpan = startPerfSpan('daemon.startup.listen', {
     process: 'daemon',
+    gatewayRunId,
   });
   const serverOptions: Parameters<typeof startControlPlaneStreamServer>[0] = {
     host: options.host,
@@ -251,13 +267,14 @@ async function main(): Promise<number> {
   const address = server.address();
   recordPerfEvent('daemon.startup.listening', {
     process: 'daemon',
+    gatewayRunId,
     host: address.address,
     port: address.port,
     auth: options.authToken === null ? 'off' : 'on',
   });
   startupSpan.end({ listening: true });
   process.stdout.write(
-    `[control-plane] listening host=${address.address} port=${String(address.port)} auth=${options.authToken === null ? 'off' : 'on'} db=${options.stateDbPath}\n`,
+    `[control-plane] listening host=${address.address} port=${String(address.port)} auth=${options.authToken === null ? 'off' : 'on'} db=${options.stateDbPath} runId=${gatewayRunId}\n`,
   );
 
   let stopRequested = false;