Add Project flow

Adds end-to-end "Add Project" surface: chooser + create/clone forms reachable from command palette and topbar, project scaffold service for local create and remote clone, and a publish-to-GitHub dialog backed by createRepository + publishCurrentProject in githubService. Supporting IPC, preload bridges, and shared types follow.

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

Author: arul28

AGENTS.md

@@ -31,6 +31,7 @@
   - `npm --prefix apps/ade-cli run test`
   - `npm --prefix apps/ade-cli run build`
 - Run the smallest relevant subset first when iterating, then finish with the broader checks that cover the touched surfaces.
+- If even running the full desktop test suit, u ahve to shard like ci
 
 ## Terminology
 

apps/desktop/src/main/main.ts

@@ -39,6 +39,7 @@ import { augmentProcessPathWithShellAndKnownCliDirs, setPathEnvValue } from "./s
 import { createAgentChatService } from "./services/chat/agentChatService";
 import { shutdownAcpCliConnections } from "./services/chat/acpCliPool";
 import { createGithubService } from "./services/github/githubService";
+import { createProjectScaffoldService } from "./services/projects/projectScaffoldService";
 import { createFeedbackReporterService } from "./services/feedback/feedbackReporterService";
 import { createPrService } from "./services/prs/prService";
 import { createPrPollingService } from "./services/prs/prPollingService";
@@ -1658,6 +1659,11 @@ app.whenReady().then(async () => {
       appDataDir: app.getPath("userData"),
     });
 
+    const projectScaffoldService = createProjectScaffoldService({
+      logger,
+      githubService,
+    });
+
     const feedbackReporterService = createFeedbackReporterService({
       db,
       logger,
@@ -3755,6 +3761,7 @@ app.whenReady().then(async () => {
       conflictService,
       aiIntegrationService,
       githubService,
+      projectScaffoldService,
       feedbackReporterService,
       prService,
       prPollingService,
@@ -3830,6 +3837,19 @@ app.whenReady().then(async () => {
     const logger = createFileLogger(
       path.join(app.getPath("userData"), "ade-idle.jsonl"),
     );
+    // Welcome-screen IPCs (project create/clone, listMyRepos) need scaffold +
+    // github services even before a project is opened. Build minimal versions
+    // here that share the user-data token store. detectRepo / publishCurrent
+    // require an active project and will throw clearly when called dormant.
+    const dormantGithubService = createGithubService({
+      logger,
+      projectRoot: normalizedRoot,
+      appDataDir: app.getPath("userData"),
+    });
+    const dormantProjectScaffoldService = createProjectScaffoldService({
+      logger,
+      githubService: dormantGithubService,
+    });
     return {
       db: null,
       logger,
@@ -3868,7 +3888,8 @@ app.whenReady().then(async () => {
       iosSimulatorService: null,
       appControlService: null,
       builtInBrowserService: null,
-      githubService: null,
+      githubService: dormantGithubService,
+      projectScaffoldService: dormantProjectScaffoldService,
       feedbackReporterService: null,
       prService: null,
       prPollingService: null,

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

@@ -571,3 +571,208 @@ describe("githubService.getStatus", () => {
     expect(status.repoAccessError).toBeNull();
   });
 });
+
+// ---------------------------------------------------------------------------
+// createRepository — POST /user/repos
+// ---------------------------------------------------------------------------
+
+describe("githubService.createRepository", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    process.env.GITHUB_TOKEN = "ghp_env_token";
+  });
+
+  function lastFetchCall() {
+    const calls = mockFetch.mock.calls;
+    return calls[calls.length - 1] as [string, RequestInit];
+  }
+
+  it("POSTs the canonical body shape and parses the response", async () => {
+    mockFetch.mockResolvedValueOnce(
+      jsonResponse(201, {
+        clone_url: "https://github.com/alice/test.git",
+        ssh_url: "git@github.com:alice/test.git",
+        html_url: "https://github.com/alice/test",
+        default_branch: "main",
+      }),
+    );
+
+    const result = await makeService().createRepository({
+      name: "test",
+      description: "hello world",
+      isPrivate: true,
+    });
+
+    const [url, init] = lastFetchCall();
+    expect(url).toContain("/user/repos");
+    expect(init.method).toBe("POST");
+    expect(JSON.parse(init.body as string)).toEqual({
+      name: "test",
+      description: "hello world",
+      private: true,
+      auto_init: false,
+    });
+    expect(result).toEqual({
+      cloneUrl: "https://github.com/alice/test.git",
+      sshUrl: "git@github.com:alice/test.git",
+      htmlUrl: "https://github.com/alice/test",
+      defaultBranch: "main",
+    });
+  });
+
+  it("omits the description field when blank", async () => {
+    mockFetch.mockResolvedValueOnce(
+      jsonResponse(201, {
+        clone_url: "https://github.com/alice/test.git",
+        ssh_url: "git@github.com:alice/test.git",
+        html_url: "https://github.com/alice/test",
+        default_branch: "main",
+      }),
+    );
+
+    await makeService().createRepository({ name: "test", isPrivate: false });
+
+    const [, init] = lastFetchCall();
+    const body = JSON.parse(init.body as string);
+    expect(body).not.toHaveProperty("description");
+    expect(body.private).toBe(false);
+  });
+
+  it("propagates GitHub error messages on 4xx", async () => {
+    mockFetch.mockResolvedValueOnce(
+      jsonResponse(422, {
+        message: "Validation Failed",
+        errors: [{ message: "name already exists on this account" }],
+      }),
+    );
+
+    await expect(
+      makeService().createRepository({ name: "existing", isPrivate: true }),
+    ).rejects.toThrow(/validation failed.*already exists/i);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// publishCurrentProject — orchestrates createRepo + remote add + push
+// ---------------------------------------------------------------------------
+
+describe("githubService.publishCurrentProject", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    process.env.GITHUB_TOKEN = "ghp_env_token";
+  });
+
+  it("returns state=pushed when HEAD exists, after creating the repo and pushing", async () => {
+    runGitMock
+      // get-url origin: no remote yet
+      .mockResolvedValueOnce({ exitCode: 1, stdout: "", stderr: "fatal: No such remote 'origin'" })
+      // remote add origin: ok
+      .mockResolvedValueOnce({ exitCode: 0, stdout: "", stderr: "" })
+      // rev-parse HEAD: ok (commit exists)
+      .mockResolvedValueOnce({ exitCode: 0, stdout: "abc123\n", stderr: "" })
+      // push -u origin HEAD: ok
+      .mockResolvedValueOnce({ exitCode: 0, stdout: "", stderr: "" });
+
+    mockFetch.mockResolvedValueOnce(
+      jsonResponse(201, {
+        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",
+      }),
+    );
+
+    const result = await makeService().publishCurrentProject({
+      name: "proj",
+      isPrivate: true,
+    });
+
+    expect(result).toEqual({ state: "pushed", htmlUrl: "https://github.com/alice/proj" });
+    const gitCalls = runGitMock.mock.calls.map((c) => c[0]);
+    expect(gitCalls[0]).toEqual(["remote", "get-url", "origin"]);
+    expect(gitCalls[1]).toEqual(["remote", "add", "origin", "https://github.com/alice/proj.git"]);
+    expect(gitCalls[2]).toEqual(["rev-parse", "--verify", "HEAD"]);
+    expect(gitCalls[3]).toEqual(["push", "-u", "origin", "HEAD"]);
+  });
+
+  it("returns state=remote_added when the project has no commits yet", async () => {
+    runGitMock
+      .mockResolvedValueOnce({ exitCode: 1, stdout: "", stderr: "" }) // get-url origin
+      .mockResolvedValueOnce({ exitCode: 0, stdout: "", stderr: "" }) // remote add
+      .mockResolvedValueOnce({ exitCode: 128, stdout: "", stderr: "fatal: Needed a single revision" }); // rev-parse HEAD fails
+
+    mockFetch.mockResolvedValueOnce(
+      jsonResponse(201, {
+        clone_url: "https://github.com/alice/empty.git",
+        ssh_url: "git@github.com:alice/empty.git",
+        html_url: "https://github.com/alice/empty",
+        default_branch: "main",
+      }),
+    );
+
+    const result = await makeService().publishCurrentProject({
+      name: "empty",
+      isPrivate: true,
+    });
+
+    expect(result).toEqual({ state: "remote_added", htmlUrl: "https://github.com/alice/empty" });
+    // Should NOT have called push
+    expect(runGitMock.mock.calls.map((c) => (c[0] as string[])[0])).not.toContain("push");
+  });
+
+  it("throws remote_already_exists when origin is already configured", async () => {
+    runGitMock.mockResolvedValueOnce({
+      exitCode: 0,
+      stdout: "git@github.com:someone/already.git\n",
+      stderr: "",
+    });
+
+    let caught: any;
+    try {
+      await makeService().publishCurrentProject({ name: "x", isPrivate: true });
+    } catch (err) {
+      caught = err;
+    }
+    expect(caught).toBeInstanceOf(Error);
+    expect(caught.code).toBe("remote_already_exists");
+    // Must NOT have hit the API
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it("throws github_not_connected when no token is stored", async () => {
+    delete process.env.GITHUB_TOKEN;
+    delete process.env.ADE_GITHUB_TOKEN;
+
+    let caught: any;
+    try {
+      await makeService().publishCurrentProject({ name: "x", isPrivate: true });
+    } catch (err) {
+      caught = err;
+    }
+    expect(caught).toBeInstanceOf(Error);
+    expect(caught.code).toBe("github_not_connected");
+    expect(runGitMock).not.toHaveBeenCalled();
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it("surfaces a clear error when the push step fails", async () => {
+    runGitMock
+      .mockResolvedValueOnce({ exitCode: 1, stdout: "", stderr: "" })
+      .mockResolvedValueOnce({ exitCode: 0, stdout: "", stderr: "" })
+      .mockResolvedValueOnce({ exitCode: 0, stdout: "abc\n", stderr: "" })
+      .mockResolvedValueOnce({ exitCode: 1, stdout: "", stderr: "Authentication failed" });
+
+    mockFetch.mockResolvedValueOnce(
+      jsonResponse(201, {
+        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",
+      }),
+    );
+
+    await expect(
+      makeService().publishCurrentProject({ name: "proj", isPrivate: true }),
+    ).rejects.toThrow(/authentication failed/i);
+  });
+});

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

@@ -17,7 +17,7 @@ function detectGitHubTokenType(token: string): GitHubStatus["tokenType"] {
   return "unknown";
 }
 
-function parseGitHubRepoFromRemoteUrl(remoteUrlRaw: string): GitHubRepoRef | null {
+export function parseGitHubRepoFromRemoteUrl(remoteUrlRaw: string): GitHubRepoRef | null {
   const remoteUrl = remoteUrlRaw.trim();
   if (!remoteUrl) return null;
 
@@ -48,7 +48,7 @@ function parseGitHubRepoFromRemoteUrl(remoteUrlRaw: string): GitHubRepoRef | nul
   return null;
 }
 
-function parseNextLink(linkHeader: string | null): string | null {
+export function parseNextLink(linkHeader: string | null): string | null {
   if (!linkHeader) return null;
   for (const part of linkHeader.split(",")) {
     const match = part.match(/<([^>]+)>;\s*rel="([^"]+)"/);
@@ -644,6 +644,80 @@ export function createGithubService({
     return data ?? null;
   };
 
+  const createRepository = async (args: {
+    name: string;
+    description?: string;
+    isPrivate: boolean;
+  }): Promise<{ cloneUrl: string; sshUrl: string; htmlUrl: string; defaultBranch: string }> => {
+    const body: Record<string, unknown> = {
+      name: args.name,
+      private: args.isPrivate,
+      auto_init: false,
+    };
+    if (args.description != null && args.description.trim().length > 0) {
+      body.description = args.description.trim();
+    }
+    const { data } = await apiRequest<Record<string, unknown>>({
+      method: "POST",
+      path: "/user/repos",
+      body,
+    });
+    return {
+      cloneUrl: asString(data.clone_url),
+      sshUrl: asString(data.ssh_url),
+      htmlUrl: asString(data.html_url),
+      defaultBranch: asString(data.default_branch) || "main",
+    };
+  };
+
+  const publishCurrentProject = async (
+    args: { name: string; description?: string; isPrivate: boolean },
+  ): Promise<{ state: "pushed" | "remote_added"; htmlUrl: string }> => {
+    if (!readStoredToken()) {
+      const err = new Error("GitHub is not connected. Add a token in Settings.") as Error & { code?: string };
+      err.code = "github_not_connected";
+      throw err;
+    }
+
+    const existingRemote = await runGit(["remote", "get-url", "origin"], { cwd: projectRoot, timeoutMs: 8_000 });
+    if (existingRemote.exitCode === 0 && existingRemote.stdout.trim().length > 0) {
+      const err = new Error("This project already has a GitHub remote named 'origin'.") as Error & { code?: string };
+      err.code = "remote_already_exists";
+      throw err;
+    }
+
+    const created = await createRepository({
+      name: args.name,
+      description: args.description,
+      isPrivate: args.isPrivate,
+    });
+
+    const remoteAddRes = await runGit(["remote", "add", "origin", created.cloneUrl], {
+      cwd: projectRoot,
+      timeoutMs: 8_000,
+    });
+    if (remoteAddRes.exitCode !== 0) {
+      throw new Error(`Failed to add origin remote: ${remoteAddRes.stderr.trim() || `exit ${remoteAddRes.exitCode}`}`);
+    }
+
+    const headRes = await runGit(["rev-parse", "--verify", "HEAD"], { cwd: projectRoot, timeoutMs: 5_000 });
+    let resultState: "pushed" | "remote_added";
+    if (headRes.exitCode === 0) {
+      const pushRes = await runGit(["push", "-u", "origin", "HEAD"], { cwd: projectRoot, timeoutMs: 5 * 60_000 });
+      if (pushRes.exitCode !== 0) {
+        throw new Error(`Failed to push to origin: ${pushRes.stderr.trim() || `exit ${pushRes.exitCode}`}`);
+      }
+      resultState = "pushed";
+    } else {
+      resultState = "remote_added";
+    }
+
+    cachedStatus = null;
+    cachedAt = 0;
+
+    return { state: resultState, htmlUrl: created.htmlUrl };
+  };
+
   return {
     getStatus,
 
@@ -675,6 +749,12 @@ export function createGithubService({
 
     detectRepo,
     apiRequest,
+    parseNextLink,
+    parseGitHubRepoFromRemoteUrl,
+
+    // Repo creation + publish
+    createRepository,
+    publishCurrentProject,
 
     // Polling/picker read helpers
     listRepoLabels,