ship: iter 2 — address greptile/codex re-review on PR #248

- projectScaffoldService.createLocalProject + cloneRepository: rollback
  the directory we created if any later step fails, so a partial scaffold
  doesn't permanently trip the target_exists guard on retry. Skip
  rollback when the dir pre-existed (greptile P1 #3184743711)
- githubService.publishCurrentProject: when createRepository 422s with
  "name already exists" and the existing repo is empty (size=0), reuse
  its cloneUrl instead of dying. Throw a coded repo_name_taken with a
  friendly message when the existing repo has commits (codex P1 #3184743954)
- useGithubProjectRemote + GitHubStatus: expose hasOrigin separately
  from repo (which only tracks GitHub origins). TopBar Publish pill now
  hides for ANY existing origin, including non-GitHub remotes that
  would otherwise dead-end at remote_already_exists (codex P2 #3184743960)

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

Author: arul28

apps/desktop/src/main/services/github/githubService.test.ts

@@ -570,6 +570,46 @@ describe("githubService.getStatus", () => {
     expect(status.repoAccessOk).toBeNull();
     expect(status.repoAccessError).toBeNull();
   });
+
+  it("reports hasOrigin=true with repo=null when origin is non-GitHub (GitLab/Bitbucket)", async () => {
+    runGitMock.mockResolvedValueOnce({
+      exitCode: 0,
+      stdout: "git@gitlab.com:acme/internal.git\n",
+      stderr: "",
+    });
+    process.env.GITHUB_TOKEN = "ghp_classic";
+    mockFetch.mockResolvedValueOnce(
+      jsonResponse(200, { login: "alice" }, { "x-oauth-scopes": "repo, workflow" }),
+    );
+
+    const status = await makeService().getStatus();
+
+    expect(status.repo).toBeNull();
+    expect(status.hasOrigin).toBe(true);
+  });
+
+  it("reports hasOrigin=false when no origin remote is configured", async () => {
+    runGitMock.mockResolvedValueOnce({ exitCode: 1, stdout: "", stderr: "fatal: no origin" });
+
+    const status = await makeService().getStatus();
+
+    expect(status.repo).toBeNull();
+    expect(status.hasOrigin).toBe(false);
+  });
+
+  it("reports hasOrigin=true with repo populated for GitHub origin", async () => {
+    stubOriginRemote();
+    process.env.GITHUB_TOKEN = "ghp_classic";
+    mockFetch.mockResolvedValueOnce(
+      jsonResponse(200, { login: "alice" }, { "x-oauth-scopes": "repo, workflow" }),
+    );
+    mockFetch.mockResolvedValueOnce(jsonResponse(200, { full_name: "acme/ade" }));
+
+    const status = await makeService().getStatus();
+
+    expect(status.repo).toEqual({ owner: "acme", name: "ade" });
+    expect(status.hasOrigin).toBe(true);
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -824,4 +864,68 @@ describe("githubService.publishCurrentProject", () => {
     const gitCalls = runGitMock.mock.calls.map((c) => c[0]);
     expect(gitCalls).toContainEqual(["remote", "remove", "origin"]);
   });
+
+  it("recovers from 'name already exists' by reusing an empty existing repo", async () => {
+    runGitMock
+      .mockResolvedValueOnce({ exitCode: 1, stdout: "", stderr: "" }) // get-url origin
+      .mockResolvedValueOnce({ exitCode: 0, stdout: "", stderr: "" }) // remote add origin
+      .mockResolvedValueOnce({ exitCode: 0, stdout: "abc\n", stderr: "" }) // rev-parse HEAD
+      .mockResolvedValueOnce({ exitCode: 0, stdout: "", stderr: "" }); // push
+
+    // 1) createRepository → 422 already exists
+    mockFetch.mockResolvedValueOnce(
+      jsonResponse(422, {
+        message: "Repository creation failed",
+        errors: [{ message: "name already exists on this account" }],
+      }),
+    );
+    // 2) validateToken /user → returns owner login
+    mockFetch.mockResolvedValueOnce(jsonResponse(200, { login: "alice" }));
+    // 3) getRepository /repos/alice/proj → empty repo
+    mockFetch.mockResolvedValueOnce(
+      jsonResponse(200, {
+        clone_url: "https://github.com/alice/proj.git",
+        ssh_url: "git@github.com:alice/proj.git",
+        html_url: "https://github.com/alice/proj",
+        default_branch: "main",
+        size: 0,
+      }),
+    );
+
+    const result = await makeService().publishCurrentProject({
+      name: "proj",
+      isPrivate: true,
+    });
+
+    expect(result).toEqual({ state: "pushed", htmlUrl: "https://github.com/alice/proj" });
+  });
+
+  it("throws repo_name_taken when the existing repo has commits", async () => {
+    runGitMock.mockResolvedValueOnce({ exitCode: 1, stdout: "", stderr: "" }); // get-url origin
+
+    mockFetch.mockResolvedValueOnce(
+      jsonResponse(422, {
+        message: "Repository creation failed",
+        errors: [{ message: "name already exists on this account" }],
+      }),
+    );
+    mockFetch.mockResolvedValueOnce(jsonResponse(200, { login: "alice" }));
+    mockFetch.mockResolvedValueOnce(
+      jsonResponse(200, {
+        clone_url: "https://github.com/alice/proj.git",
+        html_url: "https://github.com/alice/proj",
+        default_branch: "main",
+        size: 1234,
+      }),
+    );
+
+    let caught: any;
+    try {
+      await makeService().publishCurrentProject({ name: "proj", isPrivate: true });
+    } catch (err) {
+      caught = err;
+    }
+    expect(caught).toBeInstanceOf(Error);
+    expect(caught.code).toBe("repo_name_taken");
+  });
 });

apps/desktop/src/main/services/github/githubService.ts

@@ -182,6 +182,18 @@ export function createGithubService({
     return parseGitHubRepoFromRemoteUrl(res.stdout);
   };
 
+  // Returns `{ repo, hasOrigin }` in one git invocation. `hasOrigin` is true
+  // for ANY `origin` remote (GitLab/Bitbucket/etc.), while `repo` is populated
+  // only when origin parses as GitHub. Callers use `hasOrigin` to hide the
+  // Publish-to-GitHub CTA on projects with non-GitHub remotes.
+  const detectOrigin = async (): Promise<{ repo: GitHubRepoRef | null; hasOrigin: boolean }> => {
+    const res = await runGit(["remote", "get-url", "origin"], { cwd: projectRoot, timeoutMs: 8000 });
+    if (res.exitCode !== 0) return { repo: null, hasOrigin: false };
+    const url = res.stdout.trim();
+    if (!url) return { repo: null, hasOrigin: false };
+    return { repo: parseGitHubRepoFromRemoteUrl(url), hasOrigin: true };
+  };
+
   const validateToken = async (token: string): Promise<{ userLogin: string | null; scopes: string[]; tokenType: GitHubStatus["tokenType"] }> => {
     const response = await fetch("https://api.github.com/user", {
       method: "GET",
@@ -399,14 +411,15 @@ export function createGithubService({
       cachedAt = 0;
     }
     const token = readStoredToken();
-    const repo = await detectRepo().catch(() => null);
+    const { repo, hasOrigin } = await detectOrigin().catch(() => ({ repo: null, hasOrigin: false }));
     if (!token) {
       cachedStatus = {
         tokenStored: false,
         tokenDecryptionFailed,
         storageScope: "app",
         tokenType: "unknown",
         repo,
+        hasOrigin,
         userLogin: null,
         scopes: [],
         checkedAt: null,
@@ -435,7 +448,7 @@ export function createGithubService({
         repo,
         repoAccessOk,
       });
-      return { ...cachedStatus, repo, repoAccessOk, repoAccessError, connected };
+      return { ...cachedStatus, repo, hasOrigin, repoAccessOk, repoAccessError, connected };
     }
 
     try {
@@ -468,6 +481,7 @@ export function createGithubService({
         storageScope: "app",
         tokenType: validated.tokenType,
         repo,
+        hasOrigin,
         userLogin: validated.userLogin,
         scopes: validated.scopes,
         checkedAt: nowIso(),
@@ -485,6 +499,7 @@ export function createGithubService({
         storageScope: "app",
         tokenType: detectGitHubTokenType(token),
         repo,
+        hasOrigin,
         userLogin: null,
         scopes: [],
         checkedAt: nowIso(),
@@ -670,10 +685,34 @@ export function createGithubService({
     };
   };
 
+  const getRepository = async (
+    owner: string,
+    name: string,
+  ): Promise<{
+    cloneUrl: string;
+    sshUrl: string;
+    htmlUrl: string;
+    defaultBranch: string;
+    size: number;
+  }> => {
+    const { data } = await apiRequest<Record<string, unknown>>({
+      method: "GET",
+      path: `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(name)}`,
+    });
+    return {
+      cloneUrl: asString(data.clone_url),
+      sshUrl: asString(data.ssh_url),
+      htmlUrl: asString(data.html_url),
+      defaultBranch: asString(data.default_branch) || "main",
+      size: typeof data.size === "number" ? data.size : 0,
+    };
+  };
+
   const publishCurrentProject = async (
     args: { name: string; description?: string; isPrivate: boolean },
   ): Promise<{ state: "pushed" | "remote_added"; htmlUrl: string }> => {
-    if (!readStoredToken()) {
+    const token = readStoredToken();
+    if (!token) {
       const err = new Error("GitHub is not connected. Add a token in Settings.") as Error & { code?: string };
       err.code = "github_not_connected";
       throw err;
@@ -686,11 +725,42 @@ export function createGithubService({
       throw err;
     }
 
-    const created = await createRepository({
-      name: args.name,
-      description: args.description,
-      isPrivate: args.isPrivate,
-    });
+    // If a previous publish attempt created the GitHub repo but then failed
+    // before push (auth/network), `createRepository` will 422 with "name
+    // already exists". Recover by GETting the existing repo and reusing its
+    // cloneUrl — but only when it's empty (size=0), so we never overwrite
+    // an unrelated user repo with the same name.
+    let created: { cloneUrl: string; sshUrl: string; htmlUrl: string; defaultBranch: string };
+    try {
+      created = await createRepository({
+        name: args.name,
+        description: args.description,
+        isPrivate: args.isPrivate,
+      });
+    } catch (createErr) {
+      const message = createErr instanceof Error ? createErr.message : String(createErr);
+      const isNameTaken = /already exists/i.test(message);
+      if (!isNameTaken) throw createErr;
+
+      const validated = await validateToken(token).catch(() => ({ userLogin: null as string | null }));
+      const owner = validated.userLogin;
+      if (!owner) throw createErr;
+
+      const existing = await getRepository(owner, args.name);
+      if (existing.size > 0) {
+        const taken = new Error(
+          `A GitHub repo named '${args.name}' already exists on your account and contains commits. Pick a different name.`,
+        ) as Error & { code?: string };
+        taken.code = "repo_name_taken";
+        throw taken;
+      }
+      created = {
+        cloneUrl: existing.cloneUrl,
+        sshUrl: existing.sshUrl,
+        htmlUrl: existing.htmlUrl,
+        defaultBranch: existing.defaultBranch,
+      };
+    }
 
     // After createRepository succeeds, the GitHub repo exists. If we then
     // fail to add the local origin or push to it, we must remove the local
@@ -768,6 +838,7 @@ export function createGithubService({
 
     // Repo creation + publish
     createRepository,
+    getRepository,
     publishCurrentProject,
 
     // Polling/picker read helpers

apps/desktop/src/main/services/projects/projectScaffoldService.test.ts

@@ -231,6 +231,48 @@ describe("createLocalProject", () => {
       service.createLocalProject({ name: "empty-target", parentDir }),
     ).resolves.toEqual({ rootPath: empty });
   });
+
+  it("rolls back the created directory when a step after mkdir fails", async () => {
+    // init ok, then `git add .` fails after README/.gitignore are written.
+    runGitMock
+      .mockResolvedValueOnce(gitOk())
+      .mockResolvedValueOnce(gitFail("fatal: not a git repository", 128));
+
+    const parentDir = makeTempDir("ade-scaffold-rollback-");
+    const service = createProjectScaffoldService({
+      logger: makeLogger(),
+      githubService: makeGithubServiceStub(),
+    });
+
+    const rootPath = path.join(parentDir, "doomed");
+    await expect(
+      service.createLocalProject({ name: "doomed", parentDir }),
+    ).rejects.toThrow();
+
+    // The directory we created must be gone so a retry isn't blocked by target_exists.
+    expect(fs.existsSync(rootPath)).toBe(false);
+  });
+
+  it("does not roll back a pre-existing empty directory on failure", async () => {
+    runGitMock
+      .mockResolvedValueOnce(gitOk())
+      .mockResolvedValueOnce(gitFail("boom", 128));
+
+    const parentDir = makeTempDir("ade-scaffold-rollback-preexist-");
+    const rootPath = path.join(parentDir, "user-made");
+    fs.mkdirSync(rootPath);
+
+    const service = createProjectScaffoldService({
+      logger: makeLogger(),
+      githubService: makeGithubServiceStub(),
+    });
+
+    await expect(
+      service.createLocalProject({ name: "user-made", parentDir }),
+    ).rejects.toThrow();
+
+    expect(fs.existsSync(rootPath)).toBe(true);
+  });
 });
 
 describe("cloneRepository", () => {
@@ -342,6 +384,29 @@ describe("cloneRepository", () => {
       service.cloneRepository({ url: "https://github.com/octocat/Hello-World", parentDir }),
     ).rejects.toThrow(/repository not found/i);
   });
+
+  it("rolls back a partial clone directory so retry isn't blocked by target_exists", async () => {
+    const parentDir = makeTempDir("ade-scaffold-clone-rollback-");
+    const rootPath = path.join(parentDir, "Hello-World");
+
+    // Simulate `git clone` partially populating the dir then failing.
+    runGitMock.mockImplementationOnce(async () => {
+      fs.mkdirSync(rootPath);
+      fs.writeFileSync(path.join(rootPath, "partial"), "x");
+      return gitFail("fatal: authentication failed");
+    });
+
+    const service = createProjectScaffoldService({
+      logger: makeLogger(),
+      githubService: makeGithubServiceStub(),
+    });
+
+    await expect(
+      service.cloneRepository({ url: "https://github.com/octocat/Hello-World", parentDir }),
+    ).rejects.toThrow();
+
+    expect(fs.existsSync(rootPath)).toBe(false);
+  });
 });
 
 describe("listMyGitHubRepos", () => {