fix(GitClone): local checkout produces the same outputs as a clone (#195)

* fix(GitClone): produce the same outputs from a local checkout as from a clone

Two ways a local checkout silently came up short of the clone path's outputs,
leaving downstream blocks stuck on "Waiting for outputs from: … (repo_owner,
org_id, repo_name, repo_id)".

Remote resolution only ever looked at `origin` (GitClient.getInfo). A checkout
that names its remote something else — a fork whose upstream is the interesting
one, a repo re-pointed after `git init` — yielded no remote at all, so there was
no repo_owner/repo_name, and no org_id/repo_id either, since those are looked up
from the owner and name. inspectLocalRepo now falls back to whichever remote the
repo does have. `origin` is still preferred, so remote order decides nothing in
the common case.

The org/repo ids are resolved once, at confirm time, from the session token.
Because selecting a checkout deliberately didn't wait on the linked auth block,
confirming before authenticating produced a block permanently missing org_id and
repo_id. Confirming now waits for the auth block exactly as cloning does; the
path field, the folder picker, and the inline "is this a git repo?" check stay
usable while it's pending, since none of those need credentials.

Docs updated: the local source no longer claims to need no credentials, and the
no-remote caution now names the outputs that go missing with it.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* fix(GitClone): stop the local-checkout preview from reading as a finished block

The "is this a git repo?" check rendered in the same green success styling as
the completed state — check icon, root, remote, branch, file count — so a
checked directory looked like a block that had run. It hasn't: nothing is
registered and no outputs exist until "Use This Repo" is confirmed, and a block
that has produced no outputs leaves every consumer reporting each referenced
name as missing ("Waiting for outputs from: clone_repo (repo_owner, org_id,
repo_name, repo_id)") — which reads as the outputs being unsupported rather than
the block being unfinished.

The preview is now informational rather than success-styled, green being
reserved for the completed state, and says outright that the directory is not in
use yet. The no-remote warning names the outputs that go missing with it.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* uptick to 0.21.1

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* fix(GitClone): address review — docs contradictions and interrupt-safe git queries

Three findings from the review of #195.

The docs said choosing a directory "reads it only" and in the same sentence that
it "registers the repo exactly as a clone would" — the contradiction at the
heart of the reported bug. Inspection and confirmation are now described as the
separate steps they are, including that a block which hasn't been confirmed has
produced nothing and leaves its consumers reporting missing outputs.

The integration paragraph still said a pull request opens against the checkout's
`origin` remote, which contradicts the new fallback two paragraphs below it. It
now says "the checkout's remote".

firstRemoteUrl spawned git without ever killing the child, so an interrupted
fiber would orphan it. Rather than plumbing a Scope through inspectLocalRepo and
the handler — which would leave this helper inconsistent with countFiles three
lines away, which has the same property and is shared with the clone path —
the shared readGitLines helper wraps its drain in Effect.ensuring(kill). Same
guarantee, no signature change, no interruption path exists today anyway: on the
normal path the process has already exited and the signal is a no-op.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: odgrim

docs/src/content/docs/authoring/blocks/GitClone.mdx

@@ -43,7 +43,11 @@ When paired with a `<GitHubAuth>` block, the GitClone block enables a "Browse Gi
 
 Users often already have the repository cloned — a long-lived `infrastructure-live` checkout, a work in progress branch, a monorepo they never want to re-download. The block's source picker lets them choose **Use local checkout** and select that directory instead of cloning.
 
-Selecting a directory reads it only: the block resolves the repository root (so any subdirectory of the checkout works), reads the `origin` remote and current branch, and registers the repo exactly as a clone would. Nothing is fetched, pulled, or modified, and no credentials are needed — the files are already there.
+Choosing a directory only **inspects** it: the block resolves the repository root (so any subdirectory of the checkout works), reads the repository's remote and current branch, and counts its tracked files. Nothing is fetched, pulled, or modified, and nothing is registered yet — the directory is reported on, not adopted.
+
+Confirming with **Use This Repo** is what registers the checkout and produces the block's outputs, exactly as a completed clone does. Until then the block has produced nothing, and any later block referencing its outputs still reports them as missing.
+
+Inspecting a directory needs no credentials, so browsing works while a linked auth block is still pending. Confirming does wait on it, exactly as cloning does — the GitHub `org_id` / `repo_id` outputs are resolved from the session token at that moment, so adopting a checkout before authentication finishes would leave the block without them.
 
 ```mdx
 <GitClone
@@ -63,10 +67,10 @@ Setting `prefilledRepoDir` starts the block on the local source. Use `source` to
 <GitClone id="repo" source="clone" hideSourceSelect prefilledUrl="https://github.com/acme/infra" />
 ```
 
-Everything downstream behaves the same either way: the same `clone_path`, `repo_owner`, and `repo_name` outputs, the same `$REPO_FILES` variable, the same workspace file tree, and the same [`<GitPullRequest>`](/authoring/blocks/gitpullrequest) integration — a pull request opens against the checkout's `origin` remote and current branch.
+Everything downstream behaves the same either way: the same `clone_path`, `repo_owner`, and `repo_name` outputs, the same `$REPO_FILES` variable, the same workspace file tree, and the same [`<GitPullRequest>`](/authoring/blocks/gitpullrequest) integration — a pull request opens against the checkout's remote and current branch.
 
 <Aside type="caution">
-A checkout with no `origin` remote can still be selected, but blocks that open a pull request need one. The block says so inline when it finds no remote.
+A checkout with no remote at all can still be selected, but it produces no `repo_owner` / `repo_name` (nor the GitHub ids derived from them), and blocks that open a pull request need one. The block says so inline when it finds no remote. `origin` is preferred; if the checkout names its remote something else, that one is used.
 </Aside>
 
 ### Pre-filled Values
@@ -203,7 +207,7 @@ After a successful clone, the GitClone block produces outputs that can be refere
 | `repo_id` | Immutable GitHub numeric ID of the repository (when a GitHub token is available) | `87654321` |
 | `repo_url` | The full URL of the cloned repository | `https://github.com/acme-corp/infrastructure-live` |
 
-For a local checkout, `clone_path` is the repository root the user selected, and `repo_owner` / `repo_name` come from its `origin` remote (omitted when the repo has no remote).
+For a local checkout, `clone_path` is the repository root the user selected, and `repo_owner` / `repo_name` come from its remote — `origin` when present, otherwise whichever remote the checkout has. They are omitted entirely when the repo has no remote, which also means no `org_id` / `repo_id`, since those are looked up from the owner and name.
 
 Reference outputs in downstream blocks using template variables:
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "runbooks",
-  "version": "0.21.0",
+  "version": "0.21.1",
   "private": true,
   "description": "Gruntwork Runbooks",
   "author": {

src/domain/git/local-repo.test.ts

@@ -140,6 +140,31 @@ describe("inspectLocalRepo", () => {
     expect(info.owner).toBeUndefined()
   })
 
+  it("falls back to a non-origin remote when there is no origin", async () => {
+    const info = await inspect("/home/me/fork", {
+      dirs: ["/home/me/fork"],
+      commands: [
+        { command: "git", args: ["remote"], outputLines: ["upstream"], exitCode: 0 },
+        {
+          command: "git",
+          args: ["remote", "get-url", "upstream"],
+          outputLines: ["git@github.com:acme/infra.git"],
+          exitCode: 0,
+        },
+        lsFiles(["main.tf"]),
+      ],
+      git: {
+        getRepoRoot: () => Effect.succeed("/home/me/fork"),
+        // getInfo only looks at origin, which this checkout doesn't have.
+        getInfo: () => Effect.succeed({ branch: "main", refType: "branch" as const }),
+      },
+    })
+
+    expect(info.remoteUrl).toBe("git@github.com:acme/infra.git")
+    expect(info.owner).toBe("acme")
+    expect(info.repo).toBe("infra")
+  })
+
   it("omits owner/repo when the repo has no remote", async () => {
     const info = await inspect("/home/me/local-only", {
       dirs: ["/home/me/local-only"],

src/domain/git/local-repo.ts

@@ -9,12 +9,13 @@
  * `<DirPicker>` — behave identically either way.
  */
 import path from "path"
-import { Effect } from "effect"
+import { Effect, Stream, Chunk } from "effect"
 import { GitClient } from "../../services/GitClient.ts"
 import type { GitInfo } from "../../services/GitClient.ts"
 import { FileSystem } from "../../services/FileSystem.ts"
 import { ProcessSpawner } from "../../services/ProcessSpawner.ts"
 import { GitError } from "../../errors/index.ts"
+import { gitSpawnEnv } from "./env.ts"
 import { countFiles, parseOwnerRepoFromURL } from "./operations.ts"
 
 /** Metadata describing a local checkout selected by the user. */
@@ -118,14 +119,21 @@ export const inspectLocalRepo = (
       ),
     )
 
+    // getInfo only knows about `origin`. A checkout can legitimately name its
+    // remote something else — a fork whose upstream is the interesting one, or
+    // a repo re-pointed after `git init` — and without a remote there is no
+    // repo_owner/repo_name (nor the GitHub ids derived from them) for
+    // downstream blocks to consume. Fall back to whatever remote does exist.
+    const remoteUrl = info.remoteUrl ?? (yield* firstRemoteUrl(absolutePath))
+
     const fileCount = yield* countFiles(absolutePath)
-    const parsed = info.remoteUrl ? parseOwnerRepoFromURL(info.remoteUrl) : undefined
+    const parsed = remoteUrl ? parseOwnerRepoFromURL(remoteUrl) : undefined
 
     return {
       absolutePath,
       relativePath: relativeToWorkingDir(absolutePath, workingDir),
       fileCount,
-      remoteUrl: info.remoteUrl,
+      remoteUrl,
       branch: info.branch,
       refType: info.refType,
       commitSha: info.commitSha,
@@ -134,6 +142,42 @@ export const inspectLocalRepo = (
     } satisfies LocalRepoInfo
   })
 
+/**
+ * URL of the first remote the repo has, or undefined when it has none. Only
+ * consulted after `origin` comes up empty, so remote order decides nothing in
+ * the common case. Best-effort: a repo we can't read remotes from is still a
+ * usable checkout, it just yields no owner/repo.
+ */
+const firstRemoteUrl = (repoPath: string) =>
+  Effect.gen(function* () {
+    const names = yield* readGitLines(repoPath, ["remote"])
+    if (names.length === 0) return undefined
+    const urls = yield* readGitLines(repoPath, ["remote", "get-url", names[0]])
+    return urls[0]
+  }).pipe(Effect.catchAll(() => Effect.succeed(undefined)))
+
+/**
+ * Run a short git query and return its stdout lines, or none if it failed.
+ *
+ * `Effect.ensuring` kills the child if this effect is interrupted mid-flight.
+ * On the normal path the process has already exited and the signal is a no-op,
+ * so this costs nothing and leaves no orphan behind if a caller ever gains a
+ * cancellation path.
+ */
+const readGitLines = (repoPath: string, args: string[]) =>
+  Effect.gen(function* () {
+    const spawner = yield* ProcessSpawner
+    const proc = yield* spawner.spawn("git", args, { cwd: repoPath, env: gitSpawnEnv() })
+
+    return yield* Effect.gen(function* () {
+      const lines = Chunk.toArray(yield* Stream.runCollect(proc.output))
+        .filter((l) => l.source === "stdout")
+        .map((l) => l.line.trim())
+        .filter(Boolean)
+      return (yield* proc.exitCode) === 0 ? lines : []
+    }).pipe(Effect.ensuring(proc.kill.pipe(Effect.ignore)))
+  })
+
 /**
  * Display path for a checkout: relative to the working directory when it lives
  * inside it, absolute otherwise. A local checkout is usually somewhere else

web/src/components/mdx/GitClone/GitClone.tsx

@@ -382,12 +382,17 @@ function GitCloneInteractive({
   const { bg: statusClasses, icon: IconComponent, iconColor: iconClasses } = statusConfig[cloneStatus] ?? statusConfig.pending
 
   const isLocalSource = activeSource === 'local'
-  // Selecting a checkout that already exists on disk needs no credentials —
-  // only cloning does. Auth still gates the clone form as before.
+  // Browsing and checking a directory needs no credentials, so the local form
+  // stays usable while a linked auth block is still pending.
   const isFormDisabled =
     cloneStatus === 'running' || !hasAllBlockingDependencies || (!isLocalSource && !gitHubAuthMet)
   const isCloneDisabled = isFormDisabled || !gitUrl.trim()
-  const isUseRepoDisabled = isFormDisabled || localPreviewStatus !== 'valid'
+  // Confirming, though, waits for auth exactly like cloning does. The GitHub
+  // org/repo ids are resolved once, at confirm time, from the session token —
+  // adopting a checkout before the auth block finishes would silently produce a
+  // block missing org_id/repo_id, which is precisely the parity with clone that
+  // this source is supposed to keep.
+  const isUseRepoDisabled = isFormDisabled || !gitHubAuthMet || localPreviewStatus !== 'valid'
 
   // Early return for validation errors (e.g. missing id prop)
   if (validationError) {
@@ -430,14 +435,15 @@ function GitCloneInteractive({
             />
           )}
 
-          {/* Blocked state: waiting for the referenced auth block (cloning only) */}
-          {hasAllBlockingDependencies && !gitHubAuthMet && !isLocalSource && (
+          {/* Blocked state: waiting for the referenced auth block */}
+          {hasAllBlockingDependencies && !gitHubAuthMet && (
             <div className="mb-4 p-3 bg-warning-muted border border-warning/30 rounded-md flex items-start gap-2">
               <AlertTriangle className="size-4 text-warning mt-0.5 shrink-0" />
               <div>
                 <p className="text-sm font-medium text-warning-foreground m-0">Waiting for git authentication</p>
                 <p className="text-xs text-warning-foreground m-0 mt-0.5">
-                  Complete the &apos;{githubAuthId ?? gitAuthId}&apos; authentication block above before cloning.
+                  Complete the &apos;{githubAuthId ?? gitAuthId}&apos; authentication block above
+                  before {isLocalSource ? 'selecting a repository' : 'cloning'}.
                 </p>
               </div>
             </div>

web/src/components/mdx/GitClone/__tests__/GitClone.local.test.tsx

@@ -98,10 +98,24 @@ describe("GitClone — repository source picker", () => {
     expect(repoDirInput()).toBeInTheDocument()
   })
 
-  it("does not wait on an auth block to select a local checkout", () => {
+  it("keeps the directory form usable while a linked auth block is pending", () => {
     renderGitClone({ source: "local", gitAuthId: "git-auth" })
-    expect(screen.queryByText(/Waiting for git authentication/i)).not.toBeInTheDocument()
+    // Browsing and checking a directory needs no credentials...
     expect(repoDirInput()).not.toBeDisabled()
+    expect(screen.getByRole("button", { name: /Browse/i })).not.toBeDisabled()
+  })
+
+  it("waits for a linked auth block before a checkout can be confirmed", async () => {
+    renderGitClone({ source: "local", gitAuthId: "git-auth", prefilledRepoDir: "/home/me/infra" })
+
+    // ...but confirming does wait, because the GitHub org/repo ids are resolved
+    // from the session token at confirm time and can't be filled in later.
+    expect(screen.getByText(/Waiting for git authentication/i)).toBeInTheDocument()
+    await waitFor(
+      () => expect(screen.getByText(/Git repository found/i)).toBeInTheDocument(),
+      { timeout: 2000 },
+    )
+    expect(screen.getByRole("button", { name: /Use This Repo/i })).toBeDisabled()
   })
 })
 
@@ -110,7 +124,7 @@ describe("GitClone — local checkout", () => {
     renderGitClone({ source: "local", prefilledRepoDir: "/home/me/infra" })
 
     await waitFor(
-      () => expect(screen.getByText(/Git repository/i)).toBeInTheDocument(),
+      () => expect(screen.getByText(/Git repository found/i)).toBeInTheDocument(),
       { timeout: 2000 },
     )
 
@@ -161,6 +175,22 @@ describe("GitClone — local checkout", () => {
     expect(repoDirInput()).toHaveValue("/home/me/infra")
   })
 
+  it("tells the user the checked directory is not in use until confirmed", async () => {
+    renderGitClone({ source: "local", prefilledRepoDir: "/home/me/infra" })
+
+    await waitFor(
+      () => expect(screen.getByText(/Git repository found/i)).toBeInTheDocument(),
+      { timeout: 2000 },
+    )
+
+    // The preview must not read as a finished block: nothing is registered
+    // until "Use This Repo", and a block with no outputs leaves every consumer
+    // waiting on outputs that were never produced.
+    expect(screen.getByText(/Not in use yet/i)).toBeInTheDocument()
+    expect(screen.queryByText(/Using local checkout/i)).not.toBeInTheDocument()
+    expect(registerWorkTree).not.toHaveBeenCalled()
+  })
+
   it("registers the checkout as a worktree and reports success", async () => {
     const user = userEvent.setup()
     renderGitClone({ source: "local", prefilledRepoDir: "/home/me/infra" })
@@ -211,7 +241,7 @@ describe("GitClone — local checkout", () => {
     await waitFor(
       () =>
         expect(
-          screen.getByText(/remote — blocks that open a pull request need one/i),
+          screen.getByText(/blocks that open a pull request need one/i),
         ).toBeInTheDocument(),
       { timeout: 2000 },
     )

web/src/components/mdx/GitClone/components/LocalRepoForm.tsx

@@ -1,4 +1,4 @@
-import { CheckCircle, FolderOpen, Loader2, XCircle } from "lucide-react"
+import { FolderGit2, FolderOpen, Loader2, XCircle } from "lucide-react"
 import { Button } from "@/components/ui/button"
 import { InfoTooltip } from "@/components/mdx/GitPullRequest/components/InfoTooltip"
 import type { LocalRepoInfo } from "../types"
@@ -76,13 +76,18 @@ export function LocalRepoForm({
         </div>
       )}
 
+      {/* Deliberately NOT success-styled: this only reports what the directory
+          is, and no outputs exist until the user confirms below. Green is
+          reserved for the completed state, or a checked directory reads as a
+          finished block and downstream blocks look broken for want of outputs
+          nobody produced yet. */}
       {previewStatus === 'valid' && preview && (
-        <div className="p-3 bg-success-muted border border-success/30 rounded-md space-y-1">
-          <div className="flex items-center gap-2 text-sm font-medium text-success">
-            <CheckCircle className="size-4 shrink-0" />
-            Git repository
+        <div className="p-3 bg-info-muted border border-info/40 rounded-md space-y-1">
+          <div className="flex items-center gap-2 text-sm font-medium text-info">
+            <FolderGit2 className="size-4 shrink-0" />
+            Git repository found
           </div>
-          <div className="text-xs text-success space-y-0.5">
+          <div className="text-xs text-muted-foreground space-y-0.5">
             <div>
               Root: <code className="font-mono">{preview.absolutePath}</code>
             </div>
@@ -100,9 +105,14 @@ export function LocalRepoForm({
             </div>
             {!preview.remoteUrl && (
               <div className="text-warning-foreground">
-                No <code className="font-mono">origin</code> remote — blocks that open a pull request need one.
+                No remote — this repo produces no <code className="font-mono">repo_owner</code> or{' '}
+                <code className="font-mono">repo_name</code>, and blocks that open a pull request need one.
               </div>
             )}
+            <div className="pt-1 text-foreground">
+              Not in use yet — choose <strong>Use This Repo</strong> to make this repository
+              and its outputs available to later blocks.
+            </div>
           </div>
         </div>
       )}