Merge pull request #187 from proofgeist/codex/issue-185-auto-non-interactive

Author: eluce2

.changeset/cli-auto-detect-non-interactive.md

@@ -0,0 +1,5 @@
+---
+"@proofkit/cli": patch
+---
+
+Auto-detect non-interactive terminals for CLI commands in CI, scripted runs, and coding-agent environments.

packages/cli/src/index.ts

@@ -34,6 +34,7 @@ import { planInit } from "~/core/planInit.js";
 import { resolveInitRequest } from "~/core/resolveInitRequest.js";
 import type { CliFlags } from "~/core/types.js";
 import { makeLiveLayer } from "~/services/live.js";
+import { resolveNonInteractiveMode } from "~/utils/nonInteractive.js";
 import { intro } from "~/utils/prompts.js";
 import { proofGradient, renderTitle } from "~/utils/renderTitle.js";
 
@@ -76,13 +77,6 @@ export const runDefaultCommand = (rawFlags?: Partial<CliFlags>) =>
     const fsService = yield* FileSystemService;
     const consoleService = yield* ConsoleService;
     const flags = { ...defaultCliFlags, ...rawFlags };
-
-    if (cliContext.nonInteractive || flags.CI || flags.nonInteractive) {
-      throw new Error(
-        "The default command is interactive-only in non-interactive mode. Run an explicit command such as `proofkit init <name> --non-interactive`.",
-      );
-    }
-
     const settingsPath = path.join(cliContext.cwd, "proofkit.json");
     const hasProofKitProject = yield* Effect.promise(() => fsService.exists(settingsPath));
 
@@ -98,6 +92,12 @@ export const runDefaultCommand = (rawFlags?: Partial<CliFlags>) =>
       return;
     }
 
+    if (cliContext.nonInteractive || flags.CI || flags.nonInteractive) {
+      throw new Error(
+        "The default command is interactive-only in non-interactive mode. Run an explicit command such as `proofkit init <name> --non-interactive`.",
+      );
+    }
+
     intro(`No ${proofGradient("ProofKit")} project found, running \`init\``);
     yield* runInit(undefined, {
       ...flags,
@@ -117,11 +117,23 @@ function optionalChoiceOption<Choices extends readonly string[]>(name: string, c
   return optionalOption(choiceOption(name, choices).pipe(withOptionDescription(description)));
 }
 
+function getCurrentTTYState() {
+  return {
+    stdinIsTTY: process.stdin?.isTTY,
+    stdoutIsTTY: process.stdout?.isTTY,
+  };
+}
+
 function legacyEffect<T>(runLegacy: () => Promise<T>, options?: { nonInteractive?: boolean; debug?: boolean }) {
+  const nonInteractive = resolveNonInteractiveMode({
+    nonInteractive: options?.nonInteractive,
+    ...getCurrentTTYState(),
+  });
+
   return makeLiveLayer({
     cwd: process.cwd(),
     debug: options?.debug === true,
-    nonInteractive: options?.nonInteractive === true,
+    nonInteractive,
   })(Effect.promise(runLegacy));
 }
 
@@ -155,6 +167,12 @@ function makeInitCommand() {
       debug: booleanOption("debug").pipe(withOptionDescription("Run in debug mode")),
     },
     ({ dir, ...options }) => {
+      const nonInteractive = resolveNonInteractiveMode({
+        CI: options.CI,
+        nonInteractive: options.nonInteractive,
+        ...getCurrentTTYState(),
+      });
+
       const flags: CliFlags = {
         ...defaultCliFlags,
         appType: getOrUndefined(options.appType),
@@ -177,7 +195,7 @@ function makeInitCommand() {
       return makeLiveLayer({
         cwd: process.cwd(),
         debug: flags.debug === true,
-        nonInteractive: Boolean(flags.CI || flags.nonInteractive),
+        nonInteractive,
       })(runInit(getOrUndefined(dir), flags));
     },
   ).pipe(withCommandDescription("Create a new project with ProofKit"));
@@ -336,7 +354,11 @@ const rootCommand = makeCommand(
     makeLiveLayer({
       cwd: process.cwd(),
       debug: options.debug === true,
-      nonInteractive: Boolean(options.CI || options.nonInteractive),
+      nonInteractive: resolveNonInteractiveMode({
+        CI: options.CI,
+        nonInteractive: options.nonInteractive,
+        ...getCurrentTTYState(),
+      }),
     })(
       runDefaultCommand({
         ...defaultCliFlags,

packages/cli/src/utils/nonInteractive.ts

@@ -0,0 +1,35 @@
+const NON_INTERACTIVE_ENV_VARS = [
+  "CI",
+  "GITHUB_ACTIONS",
+  "CODEX",
+  "OPENAI_CODEX",
+  "CLAUDE_CODE",
+  "JENKINS_URL",
+  "BUILDKITE",
+] as const;
+
+export function detectNonInteractiveTerminal(options?: {
+  stdinIsTTY?: boolean;
+  stdoutIsTTY?: boolean;
+  env?: NodeJS.ProcessEnv;
+}): boolean {
+  const env = options?.env ?? process.env;
+  const hasTTY = options?.stdinIsTTY === true && options?.stdoutIsTTY === true;
+  const hasNonInteractiveEnv = NON_INTERACTIVE_ENV_VARS.some((name) => Boolean(env[name]));
+  const hasDumbTerm = env.TERM === "dumb";
+  return !hasTTY || hasNonInteractiveEnv || hasDumbTerm;
+}
+
+export function resolveNonInteractiveMode(options?: {
+  CI?: boolean;
+  nonInteractive?: boolean;
+  stdinIsTTY?: boolean;
+  stdoutIsTTY?: boolean;
+  env?: NodeJS.ProcessEnv;
+}) {
+  if (options?.nonInteractive === true || options?.CI === true) {
+    return true;
+  }
+
+  return detectNonInteractiveTerminal(options);
+}

packages/cli/tests/cli.test.ts

@@ -58,6 +58,17 @@ describe("proofkit CLI", () => {
     expect(`${result.stdout}\n${result.stderr}`).toContain("proofkit init <name> --non-interactive");
   });
 
+  it("auto-detects piped execution as non-interactive", () => {
+    const result = spawnSync("node", [distEntry], {
+      cwd: packageDir,
+      stdio: "pipe",
+      encoding: "utf8",
+    });
+
+    expect(result.status).not.toBe(0);
+    expect(`${result.stdout}\n${result.stderr}`).toContain("interactive-only in non-interactive mode");
+  });
+
   it("runs when invoked through a symlinked bin path", async () => {
     const shimDir = await fs.mkdtemp(path.join(os.tmpdir(), "proofkit-new-cli-shim-"));
     const shimPath = path.join(shimDir, "proofkit");

packages/cli/tests/non-interactive.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, it } from "vitest";
+import { detectNonInteractiveTerminal, resolveNonInteractiveMode } from "~/utils/nonInteractive.js";
+
+describe("non-interactive detection", () => {
+  it("treats piped terminals as non-interactive", () => {
+    expect(
+      detectNonInteractiveTerminal({
+        stdinIsTTY: false,
+        stdoutIsTTY: true,
+        env: {},
+      }),
+    ).toBe(true);
+  });
+
+  it("treats TERM=dumb as non-interactive", () => {
+    expect(
+      detectNonInteractiveTerminal({
+        stdinIsTTY: true,
+        stdoutIsTTY: true,
+        env: { TERM: "dumb" },
+      }),
+    ).toBe(true);
+  });
+
+  it("treats coding-agent env vars as non-interactive even with a tty", () => {
+    expect(
+      detectNonInteractiveTerminal({
+        stdinIsTTY: true,
+        stdoutIsTTY: true,
+        env: { CODEX: "1" },
+      }),
+    ).toBe(true);
+  });
+
+  it("treats OPENAI_CODEX as non-interactive even with a tty", () => {
+    expect(
+      detectNonInteractiveTerminal({
+        stdinIsTTY: true,
+        stdoutIsTTY: true,
+        env: { OPENAI_CODEX: "1" },
+      }),
+    ).toBe(true);
+  });
+
+  it("keeps real terminals interactive when no signals are present", () => {
+    expect(
+      detectNonInteractiveTerminal({
+        stdinIsTTY: true,
+        stdoutIsTTY: true,
+        env: {},
+      }),
+    ).toBe(false);
+  });
+
+  it("lets explicit flags force non-interactive mode", () => {
+    expect(
+      resolveNonInteractiveMode({
+        nonInteractive: true,
+        stdinIsTTY: true,
+        stdoutIsTTY: true,
+        env: {},
+      }),
+    ).toBe(true);
+    expect(
+      resolveNonInteractiveMode({
+        CI: true,
+        stdinIsTTY: true,
+        stdoutIsTTY: true,
+        env: {},
+      }),
+    ).toBe(true);
+  });
+});