inflight-cli 2.13.0 → 2.14.0

package/dist/commands/share.js

@@ -44,7 +44,7 @@ function appendWidgetToken(url, widgetToken) {
     return parsed.toString();
 }
 /**
- * Builds a next_command string carrying forward relevant opts from the current run. test
+ * Builds a next_command string carrying forward relevant opts from the current run.
  */
 function buildNextCommand(base, opts) {
     const parts = [base];
@@ -52,8 +52,8 @@ function buildNextCommand(base, opts) {
         parts.push(`--workspace ${opts.workspace}`);
     if (opts.provider)
         parts.push(`--provider ${opts.provider}`);
-    if (opts.deployment)
-        parts.push(`--deployment ${opts.deployment}`);
+    if (opts.url)
+        parts.push(`--url ${opts.url}`);
     if (opts.project)
         parts.push(`--project ${opts.project}`);
     if (opts.versionMode)
@@ -67,376 +67,208 @@ function buildNextCommand(base, opts) {
  */
 async function checkAndSyncGit(cwd, opts = {}) {
     const state = getGitSyncState(cwd);
-    if (state.status === "clean" || state.status === "detached") {
-        return { justPushed: false };
-    }
-    // After ruling out clean/detached, branch is guaranteed non-null
-    if (!state.branch)
-        return { justPushed: false };
-    const { branch } = state;
-    if (state.status === "uncommitted") {
-        // Show changed files
-        const maxFiles = 8;
-        const display = state.changedFiles.slice(0, maxFiles);
-        const lines = display.map((line) => {
-            const trimmed = line.trim();
-            // Parse git porcelain status: "M file.ts", "?? file.ts", "A file.ts", etc.
-            const match = trimmed.match(/^(\S+)\s+(.+)$/);
-            if (!match)
-                return `  ${pc.dim(trimmed)}`;
-            const status = match[1];
-            const file = match[2];
-            const label = status === "??"
-                ? "new"
-                : status === "M"
-                    ? "modified"
-                    : status === "A"
-                        ? "added"
-                        : status === "D"
-                            ? "deleted"
-                            : status === "R"
-                                ? "renamed"
-                                : "changed";
-            return `  ${pc.dim(file)} ${pc.dim(`(${label})`)}`;
-        });
-        if (state.changedFiles.length > maxFiles) {
-            lines.push(`  ${pc.dim(`... and ${state.changedFiles.length - maxFiles} more`)}`);
-        }
-        if (isAgent) {
-            agentActionRequired({
-                type: "git_uncommitted",
-                message: "There are uncommitted changes that won't be in the deployment. Ask the user what to do.",
-                choices: [
-                    { id: "commit_push", label: "Commit and push these changes" },
-                    { id: "continue", label: "Continue without committing" },
-                ],
-                instructions: {
-                    commit_push: "Stage the changes, commit with a descriptive message, and push. Then re-run with the next_command.",
-                    continue: "Re-run with the next_command without committing.",
-                },
-                nextCommand: buildNextCommand("inflight share --skip-git-check", opts),
-            });
-        }
-        lines.push("", pc.yellow("Your deployment won't include these changes."));
-        p.log.warn("You have uncommitted changes:\n" + lines.join("\n"));
-        const action = await p.select({
-            message: "What would you like to do?",
-            options: [
-                { value: "commit_push", label: "Commit & push (recommended)" },
-                { value: "continue", label: "Continue anyway — use existing deployment" },
-            ],
-        });
-        if (p.isCancel(action)) {
-            p.cancel("Cancelled.");
-            process.exit(0);
-        }
-        if (action === "continue") {
+    switch (state.status) {
+        case "clean":
+        case "detached":
             return { justPushed: false };
-        }
-        // Commit & push flow
-        const defaultMessage = generateCommitMessage(state.branch);
-        const message = await p.text({
-            message: "Commit message",
-            initialValue: defaultMessage,
-            validate: (v) => {
-                if (!v || !v.trim())
-                    return "Commit message is required";
-            },
-        });
-        if (p.isCancel(message)) {
-            p.cancel("Cancelled.");
-            process.exit(0);
-        }
-        const spinner = p.spinner();
-        spinner.start("Committing and pushing...");
-        try {
-            commitAndPush(cwd, message.trim(), branch);
-            spinner.stop("Changes pushed!");
-            return { justPushed: true };
-        }
-        catch (e) {
-            const stderr = e && typeof e === "object" && "stderr" in e ? String(e.stderr).trim() : "";
-            spinner.stop("Push failed.");
-            if (stderr)
-                p.log.message(pc.dim(stderr));
-            else if (e instanceof Error)
-                p.log.message(pc.dim(e.message));
-            p.log.warn("Continuing with existing deployment.");
-            return { justPushed: false };
-        }
-    }
-    if (state.status === "unpushed") {
-        // Show unpushed commits
-        const commitLines = state.unpushedCommits.slice(0, 5).map((line) => `  ${pc.dim(line)}`);
-        if (state.unpushedCommits.length > 5) {
-            commitLines.push(`  ${pc.dim(`... and ${state.unpushedCommits.length - 5} more`)}`);
-        }
-        if (isAgent) {
-            agentActionRequired({
-                type: "git_unpushed",
-                message: "There are unpushed commits that won't be in the deployment. Ask the user what to do.",
-                choices: [
-                    { id: "push", label: "Push these commits" },
-                    { id: "continue", label: "Continue without pushing" },
-                ],
-                instructions: {
-                    push: "Run `git push` to push the commits. Then re-run with the next_command.",
-                    continue: "Re-run with the next_command without pushing.",
-                },
-                nextCommand: buildNextCommand("inflight share --skip-git-check", opts),
+        case "uncommitted": {
+            const { branch, changedFiles } = state;
+            const maxFiles = 8;
+            const display = changedFiles.slice(0, maxFiles);
+            const lines = display.map((line) => {
+                const trimmed = line.trim();
+                const match = trimmed.match(/^(\S+)\s+(.+)$/);
+                if (!match)
+                    return `  ${pc.dim(trimmed)}`;
+                const status = match[1];
+                const file = match[2];
+                const label = status === "??"
+                    ? "new"
+                    : status === "M"
+                        ? "modified"
+                        : status === "A"
+                            ? "added"
+                            : status === "D"
+                                ? "deleted"
+                                : status === "R"
+                                    ? "renamed"
+                                    : "changed";
+                return `  ${pc.dim(file)} ${pc.dim(`(${label})`)}`;
             });
-        }
-        commitLines.push("", pc.yellow("Your deployment won't include these commits."));
-        p.log.warn("You have unpushed commits:\n" + commitLines.join("\n"));
-        const action = await p.select({
-            message: "What would you like to do?",
-            options: [
-                { value: "push", label: "Push (recommended)" },
-                { value: "continue", label: "Continue anyway — use existing deployment" },
-            ],
-        });
-        if (p.isCancel(action)) {
-            p.cancel("Cancelled.");
-            process.exit(0);
-        }
-        if (action === "continue") {
-            return { justPushed: false };
-        }
-        const spinner = p.spinner();
-        spinner.start("Pushing...");
-        try {
-            pushBranch(cwd, branch);
-            spinner.stop("Changes pushed!");
-            return { justPushed: true };
-        }
-        catch (e) {
-            const stderr = e && typeof e === "object" && "stderr" in e ? String(e.stderr).trim() : "";
-            spinner.stop("Push failed.");
-            if (stderr)
-                p.log.message(pc.dim(stderr));
-            else if (e instanceof Error)
-                p.log.message(pc.dim(e.message));
-            p.log.warn("Continuing with existing deployment.");
-            return { justPushed: false };
-        }
-    }
-    if (state.status === "no_remote") {
-        // Working tree is clean (uncommitted was checked first in getGitSyncState).
-        // Check if this branch actually has commits ahead of the default branch —
-        // if not, pushing won't trigger a deployment.
-        if (!hasCommitsAhead(cwd)) {
-            p.log.info(`Branch ${pc.bold(branch)} has no new commits — using existing deployments.`);
-            return { justPushed: false };
-        }
-        if (isAgent) {
-            agentActionRequired({
-                type: "git_no_remote",
-                message: `Branch "${branch}" hasn't been pushed yet — no deployment exists. Ask the user what to do.`,
-                choices: [
-                    { id: "push", label: "Push to create a deployment" },
-                    { id: "continue", label: "Continue without pushing" },
+            if (changedFiles.length > maxFiles) {
+                lines.push(`  ${pc.dim(`... and ${changedFiles.length - maxFiles} more`)}`);
+            }
+            if (isAgent) {
+                agentActionRequired({
+                    type: "git_uncommitted",
+                    message: "There are uncommitted changes that won't be in the deployment. Ask the user what to do.",
+                    choices: [
+                        { id: "commit_push", label: "Commit and push these changes" },
+                        { id: "continue", label: "Continue without committing" },
+                    ],
+                    instructions: {
+                        commit_push: "Stage the changes, commit with a descriptive message, and push. Then re-run with the next_command.",
+                        continue: "Re-run with the next_command without committing.",
+                    },
+                    nextCommand: buildNextCommand("inflight share --skip-git-check", opts),
+                });
+            }
+            lines.push("", pc.yellow("Your deployment won't include these changes."));
+            p.log.warn("You have uncommitted changes:\n" + lines.join("\n"));
+            const action = await p.select({
+                message: "What would you like to do?",
+                options: [
+                    { value: "commit_push", label: "Commit & push (recommended)" },
+                    { value: "continue", label: "Continue anyway — use existing deployment" },
                 ],
-                instructions: {
-                    push: "Run `git push -u origin ${branch}` to push the branch. Then re-run with the next_command.",
-                    continue: "Re-run with the next_command without pushing.",
+            });
+            if (p.isCancel(action)) {
+                p.cancel("Cancelled.");
+                process.exit(0);
+            }
+            if (action === "continue") {
+                return { justPushed: false };
+            }
+            const defaultMessage = generateCommitMessage(branch);
+            const message = await p.text({
+                message: "Commit message",
+                initialValue: defaultMessage,
+                validate: (v) => {
+                    if (!v || !v.trim())
+                        return "Commit message is required";
                 },
-                nextCommand: buildNextCommand("inflight share --skip-git-check", opts),
             });
-        }
-        p.log.warn(`Branch ${pc.bold(branch)} hasn't been pushed yet — no deployment exists.`);
-        const confirm = await p.confirm({
-            message: "Push to create a deployment?",
-        });
-        if (p.isCancel(confirm)) {
-            p.cancel("Cancelled.");
-            process.exit(0);
-        }
-        if (!confirm) {
-            return { justPushed: false };
-        }
-        const spinner = p.spinner();
-        spinner.start("Pushing...");
-        try {
-            pushBranch(cwd, branch);
-            spinner.stop("Branch pushed!");
-            return { justPushed: true };
-        }
-        catch (e) {
-            const stderr = e && typeof e === "object" && "stderr" in e ? String(e.stderr).trim() : "";
-            spinner.stop("Push failed.");
-            if (stderr)
-                p.log.message(pc.dim(stderr));
-            else if (e instanceof Error)
-                p.log.message(pc.dim(e.message));
-            return { justPushed: false };
-        }
-    }
-    return { justPushed: false };
-}
-/**
- * Agent mode share flow.
- * Mirrors every human prompt with action_required JSON.
- * Polling runs normally (no spinners).
- * Git is NOT touched — if there's dirty state, action_required is returned
- * and the agent handles git itself, then re-runs with --skip-git-check.
- */
-async function agentShareFlow(cwd, apiKey, workspaceId, opts) {
-    // ── Git sync — report state, don't touch git ──
-    if (!opts.skipGitCheck) {
-        // checkAndSyncGit will call agentActionRequired and exit if git is dirty
-        await checkAndSyncGit(cwd, opts);
-        // If we reach here, git is clean
-    }
-    const gitInfo = getGitInfo(cwd);
-    // ── Resolve staging URL ──
-    let stagingUrl;
-    if (opts.deployment) {
-        // --deployment flag provided
-        stagingUrl = opts.deployment;
-        if (!stagingUrl.startsWith("http"))
-            stagingUrl = `https://${stagingUrl}`;
-    }
-    else {
-        // Determine provider
-        let providerId = opts.provider;
-        if (!providerId) {
-            // Auto-detect from local config files
-            const gitRoot = getGitRoot(cwd);
-            if (gitRoot && readLocalVercelProject(gitRoot)) {
-                providerId = "vercel";
+            if (p.isCancel(message)) {
+                p.cancel("Cancelled.");
+                process.exit(0);
+            }
+            const spinner = p.spinner();
+            spinner.start("Committing and pushing...");
+            try {
+                commitAndPush(cwd, message, branch);
+                spinner.stop("Changes pushed!");
+                return { justPushed: true };
+            }
+            catch (e) {
+                const stderr = e && typeof e === "object" && "stderr" in e ? String(e.stderr).trim() : "";
+                spinner.stop("Push failed.");
+                if (stderr)
+                    p.log.message(pc.dim(stderr));
+                else if (e instanceof Error)
+                    p.log.message(pc.dim(e.message));
+                p.log.warn("Continuing with existing deployment.");
+                return { justPushed: false };
             }
-            else if (gitRoot && readLocalNetlifySite(gitRoot)) {
-                providerId = "netlify";
+        }
+        case "unpushed": {
+            const { branch, unpushedCommits } = state;
+            const maxCommits = 5;
+            const commitLines = unpushedCommits.slice(0, maxCommits).map((line) => `  ${pc.dim(line)}`);
+            if (unpushedCommits.length > maxCommits) {
+                commitLines.push(`  ${pc.dim(`... and ${unpushedCommits.length - maxCommits} more`)}`);
             }
-            else {
+            if (isAgent) {
                 agentActionRequired({
-                    type: "choose_provider",
-                    message: "Could not auto-detect deployment provider. Ask the user which one they use.",
+                    type: "git_unpushed",
+                    message: "There are unpushed commits that won't be in the deployment. Ask the user what to do.",
                     choices: [
-                        { id: "vercel", label: "Vercel" },
-                        { id: "netlify", label: "Netlify" },
+                        { id: "push", label: "Push these commits" },
+                        { id: "continue", label: "Continue without pushing" },
                     ],
-                    nextCommand: "inflight share --skip-git-check --provider <ID>",
+                    instructions: {
+                        push: "Run `git push` to push the commits. Then re-run with the next_command.",
+                        continue: "Re-run with the next_command without pushing.",
+                    },
+                    nextCommand: buildNextCommand("inflight share --skip-git-check", opts),
                 });
             }
-        }
-        const provider = providers.find((prov) => prov.id === providerId);
-        if (!provider) {
-            agentError({
-                type: "invalid_provider",
-                message: `Unknown provider "${providerId}". Use "vercel" or "netlify".`,
-            });
-        }
-        stagingUrl = (await provider.resolve(cwd, gitInfo, {})) ?? undefined;
-        if (stagingUrl && !stagingUrl.startsWith("http")) {
-            stagingUrl = `https://${stagingUrl}`;
-        }
-        if (!stagingUrl) {
-            agentError({
-                type: "no_deployment",
-                message: "Could not find a deployment URL. Provide one with --url.",
-                suggestion: "inflight share --url <staging-url>",
-            });
-        }
-    }
-    // At this point stagingUrl is guaranteed set — provider.resolve returned a value or agentError exited
-    const resolvedUrl = stagingUrl;
-    // ── Resolve project ──
-    let selectedProjectId;
-    let overrideVersionId;
-    if (opts.project) {
-        if (opts.project !== "new") {
-            selectedProjectId = opts.project;
-        }
-    }
-    else {
-        const { projects } = await apiGetRecentProjects(apiKey, workspaceId, 20).catch(() => ({
-            projects: [],
-        }));
-        if (projects.length > 0) {
-            const currentBranch = gitInfo.branch;
-            agentActionRequired({
-                type: "choose_project",
-                message: "Ask the user which project to share into. Present all choices below as a numbered list.",
-                choices: [
-                    { id: "new", label: "Start a new project" },
-                    ...projects.map((proj) => ({
-                        id: proj.projectId,
-                        label: proj.latestVersion.title,
-                        hint: [
-                            proj.latestVersion.branch === currentBranch
-                                ? "current branch"
-                                : proj.latestVersion.branch,
-                            proj.latestVersion.branch === currentBranch ? "(recommended)" : undefined,
-                        ]
-                            .filter(Boolean)
-                            .join(" ") || undefined,
-                    })),
+            commitLines.push("", pc.yellow("Your deployment won't include these commits."));
+            p.log.warn("You have unpushed commits:\n" + commitLines.join("\n"));
+            const action = await p.select({
+                message: "What would you like to do?",
+                options: [
+                    { value: "push", label: "Push (recommended)" },
+                    { value: "continue", label: "Continue anyway — use existing deployment" },
                 ],
-                nextCommand: `inflight share --skip-git-check --deployment ${resolvedUrl} --project <ID>`,
             });
+            if (p.isCancel(action)) {
+                p.cancel("Cancelled.");
+                process.exit(0);
+            }
+            if (action === "continue") {
+                return { justPushed: false };
+            }
+            const spinner = p.spinner();
+            spinner.start("Pushing...");
+            try {
+                pushBranch(cwd, branch);
+                spinner.stop("Changes pushed!");
+                return { justPushed: true };
+            }
+            catch (e) {
+                const stderr = e && typeof e === "object" && "stderr" in e ? String(e.stderr).trim() : "";
+                spinner.stop("Push failed.");
+                if (stderr)
+                    p.log.message(pc.dim(stderr));
+                else if (e instanceof Error)
+                    p.log.message(pc.dim(e.message));
+                p.log.warn("Continuing with existing deployment.");
+                return { justPushed: false };
+            }
         }
-    }
-    // ── Resolve override vs new version ──
-    if (selectedProjectId && !opts.versionMode) {
-        const { projects } = await apiGetRecentProjects(apiKey, workspaceId, 20).catch(() => ({
-            projects: [],
-        }));
-        const selectedProject = projects.find((proj) => proj.projectId === selectedProjectId);
-        if (selectedProject && selectedProject.latestVersion.commentCount === 0) {
-            agentActionRequired({
-                type: "choose_override",
-                message: `"${selectedProject.latestVersion.title}" has no feedback yet. Ask the user whether to update it or create a new version.`,
-                choices: [
-                    {
-                        id: "override",
-                        label: "Update its staging URL",
-                        hint: `replace with ${new URL(resolvedUrl).hostname}`,
-                    },
-                    {
-                        id: "new_version",
-                        label: "Add a new version",
-                        hint: "keep both in version history",
+        case "no_remote": {
+            const { branch } = state;
+            if (!hasCommitsAhead(cwd)) {
+                if (isAgent) {
+                    agentError({
+                        type: "no_changes",
+                        message: `No changes on branch "${branch}" yet. Make some changes and push before sharing.`,
+                    });
+                }
+                p.log.warn("You haven't made any changes on this branch yet. There's nothing to deploy.");
+                process.exit(0);
+            }
+            if (isAgent) {
+                agentActionRequired({
+                    type: "git_no_remote",
+                    message: `Branch "${branch}" hasn't been pushed yet. Push it to create a deployment.`,
+                    choices: [{ id: "push", label: "Push to create a deployment" }],
+                    instructions: {
+                        push: `Run \`git push -u origin ${branch}\`. Then re-run with the next_command.`,
                     },
-                ],
-                instructions: {
-                    override: `Re-run with: inflight share --skip-git-check --deployment ${resolvedUrl} --project ${selectedProjectId} --version-mode override`,
-                    new_version: `Re-run with: inflight share --skip-git-check --deployment ${resolvedUrl} --project ${selectedProjectId} --version-mode new`,
-                },
-                nextCommand: `inflight share --skip-git-check --deployment ${resolvedUrl} --project ${selectedProjectId} --version-mode <override|new>`,
+                    nextCommand: buildNextCommand("inflight share --skip-git-check", opts),
+                });
+            }
+            p.log.warn("Your changes haven't been pushed yet — there's no deployment to share.");
+            const confirm = await p.confirm({
+                message: "Push now?",
             });
+            if (p.isCancel(confirm) || !confirm) {
+                p.cancel("Push your changes first, then run inflight share again.");
+                process.exit(0);
+            }
+            const spinner = p.spinner();
+            spinner.start("Pushing...");
+            try {
+                pushBranch(cwd, branch);
+                spinner.stop("Changes pushed!");
+                return { justPushed: true };
+            }
+            catch (e) {
+                const stderr = e && typeof e === "object" && "stderr" in e ? String(e.stderr).trim() : "";
+                spinner.stop("Push failed.");
+                if (stderr)
+                    p.log.message(pc.dim(stderr));
+                else if (e instanceof Error)
+                    p.log.message(pc.dim(e.message));
+                p.log.info("Ask your AI agent to push your changes, then run inflight share again.");
+                process.exit(1);
+            }
         }
     }
-    if (opts.versionMode === "override" && selectedProjectId) {
-        const { projects } = await apiGetRecentProjects(apiKey, workspaceId, 20).catch(() => ({
-            projects: [],
-        }));
-        const selectedProject = projects.find((proj) => proj.projectId === selectedProjectId);
-        if (selectedProject) {
-            overrideVersionId = selectedProject.latestVersion.id;
-        }
-    }
-    // ── Create version ──
-    const result = await apiCreateVersion({
-        apiKey,
-        workspaceId,
-        stagingUrl: resolvedUrl,
-        gitInfo,
-        ...(selectedProjectId && { projectId: selectedProjectId }),
-        ...(overrideVersionId && { overrideVersionId }),
-    }).catch((e) => {
-        agentError({ type: "create_failed", message: e.message });
-    });
-    await open(appendWidgetToken(resolvedUrl, result.widgetToken));
-    agentSuccess({
-        stagingUrl: resolvedUrl,
-        ...result,
-        isOverride: !!overrideVersionId,
-    });
 }
 export async function shareCommand(opts = {}) {
     const cwd = process.cwd();
-    // TODO: Add a step to login if not authenticated
     // ── Step 1: Auth ──
     const auth = readGlobalAuth();
     if (!auth) {
@@ -456,6 +288,14 @@ export async function shareCommand(opts = {}) {
         process.exit(1);
     }
     let gitInfo = getGitInfo(cwd);
+    const gitRoot = getGitRoot(cwd);
+    if (!gitInfo || !gitRoot) {
+        if (isAgent) {
+            agentError({ type: "not_git_repo", message: "Not a git repository." });
+        }
+        p.log.error("Not a git repository.");
+        process.exit(1);
+    }
     // ── Step 2: Resolve workspace ──
     const me = await apiGetMe(auth.apiKey).catch((e) => {
         if (isAgent)
@@ -472,85 +312,97 @@ export async function shareCommand(opts = {}) {
         explicitId: opts.workspace,
         commandForNext: "inflight share",
     });
-    // ── Fast path: URL provided (agent / scripting) ──
+    // ── Step 3: Resolve staging URL ──
+    let stagingUrl = null;
+    let justPushed = false;
+    let provider;
     if (opts.url) {
-        let stagingUrl = opts.url;
-        if (!stagingUrl.startsWith("http")) {
-            stagingUrl = `https://${stagingUrl}`;
-        }
-        if (!isValidHostedUrl(stagingUrl)) {
-            const message = stagingUrl.includes("localhost")
-                ? "Inflight needs a hosted URL — localhost isn't accessible to your team. Deploy to Vercel, Netlify, or another hosting provider first."
-                : "Must be a hosted URL with a domain (e.g., my-branch.vercel.app)";
-            if (isAgent)
-                agentError({ type: "invalid_url", message });
-            if (opts.json) {
-                console.log(JSON.stringify({ error: "invalid_url", message }));
-            }
-            else {
-                p.log.error(message);
+        // --url flag provided (agent re-invocation or scripting)
+        stagingUrl = opts.url;
+    }
+    else if (opts.provider) {
+        // --provider flag explicitly passed — validate it
+        provider = providers.find((prov) => prov.id === opts.provider);
+        if (!provider) {
+            if (isAgent) {
+                agentError({
+                    type: "invalid_provider",
+                    message: `Unknown provider "${opts.provider}". Use "vercel" or "netlify".`,
+                });
             }
+            p.log.error(`Unknown provider "${opts.provider}".`);
             process.exit(1);
         }
-        const result = await apiCreateVersion({
-            apiKey: auth.apiKey,
-            workspaceId,
-            stagingUrl,
-            gitInfo,
-            ...(opts.project && opts.project !== "new" && { projectId: opts.project }),
-        }).catch((e) => {
-            if (isAgent)
-                agentError({ type: "create_failed", message: e.message });
-            if (opts.json) {
-                console.log(JSON.stringify({ error: "create_failed", message: e.message }));
+    }
+    else {
+        // No URL or provider — detect or prompt
+        let providerId;
+        // Auto-detect from local config files
+        const hasVercel = !!readLocalVercelProject(gitRoot);
+        const hasNetlify = !!readLocalNetlifySite(gitRoot);
+        if (hasVercel && !hasNetlify) {
+            providerId = "vercel";
+        }
+        else if (hasNetlify && !hasVercel) {
+            providerId = "netlify";
+        }
+        else if (isAgent) {
+            // Both exist (monorepo), neither exists, or can't determine — ask agent
+            agentActionRequired({
+                type: "choose_provider",
+                message: "Could not auto-detect deployment provider. Ask the user which one they use.",
+                choices: [
+                    { id: "vercel", label: "Vercel" },
+                    { id: "netlify", label: "Netlify" },
+                    { id: "manual", label: "Paste a URL" },
+                ],
+                instructions: {
+                    vercel: buildNextCommand("inflight share --skip-git-check --provider vercel", opts),
+                    netlify: buildNextCommand("inflight share --skip-git-check --provider netlify", opts),
+                    manual: "Ask the user for their staging URL, then re-run with: inflight share --url <staging-url>",
+                },
+                nextCommand: buildNextCommand("inflight share --skip-git-check --provider <ID>", opts),
+            });
+        }
+        else {
+            // Can't auto-detect — prompt user
+            const providerChoice = await p.select({
+                message: "Where is your staging URL hosted?",
+                options: [
+                    ...providers.map((prov) => ({ value: prov.id, label: prov.label })),
+                    { value: "manual", label: "Paste a URL" },
+                ],
+            });
+            if (p.isCancel(providerChoice)) {
+                p.cancel("Cancelled.");
+                process.exit(0);
             }
-            else {
-                p.log.error(e.message);
+            if (providerChoice !== "manual") {
+                providerId = providerChoice;
             }
-            process.exit(1);
-        });
-        if (isAgent) {
-            await open(appendWidgetToken(stagingUrl, result.widgetToken));
-            agentSuccess({ stagingUrl, ...result });
         }
-        if (opts.json) {
-            console.log(JSON.stringify({ success: true, stagingUrl, ...result }));
-        }
-        else {
-            p.log.info(`Staging URL: ${pc.cyan(stagingUrl)}`);
-            p.outro(pc.green("✓ Inflight added to your staging URL") + " — opening in browser...");
+        if (providerId) {
+            provider = providers.find((prov) => prov.id === providerId);
         }
-        await open(appendWidgetToken(stagingUrl, result.widgetToken));
-        return;
-    }
-    // ── Agent mode: structured flow with action_required for every choice ──
-    if (isAgent) {
-        await agentShareFlow(cwd, auth.apiKey, workspaceId, opts);
-        return;
-    }
-    // Resolve staging URL
-    const providerChoice = await p.select({
-        message: "Where is your staging URL hosted?",
-        options: [
-            ...providers.map((prov) => ({ value: prov.id, label: prov.label })),
-            { value: "manual", label: "Paste a URL" },
-        ],
-    });
-    if (p.isCancel(providerChoice)) {
-        p.cancel("Cancelled.");
-        process.exit(0);
     }
-    let stagingUrl;
-    const provider = providers.find((prov) => prov.id === providerChoice);
+    // Resolve URL from provider
     if (provider) {
-        const { justPushed } = await checkAndSyncGit(cwd);
-        // Re-fetch git info after potential commit/push so provider AND apiCreateVersion see latest state
-        if (justPushed) {
-            gitInfo = getGitInfo(cwd);
+        if (!opts.skipGitCheck) {
+            ({ justPushed } = await checkAndSyncGit(cwd, opts));
+            if (justPushed) {
+                gitInfo = getGitInfo(cwd) ?? gitInfo;
+            }
         }
-        stagingUrl = (await provider.resolve(cwd, gitInfo, { justPushed })) ?? undefined;
+        stagingUrl = await provider.resolve(gitRoot, gitInfo, { justPushed });
     }
     if (!stagingUrl) {
+        if (isAgent) {
+            agentError({
+                type: "no_deployment",
+                message: "Could not find a deployment URL. Provide one with --url.",
+                suggestion: "inflight share --url <staging-url>",
+            });
+        }
         const input = await p.text({
             message: "Staging URL",
             placeholder: "my-branch.vercel.app",
@@ -582,68 +434,127 @@ export async function shareCommand(opts = {}) {
     // ── Step 4: Project selection ──
     let selectedProjectId;
     let overrideVersionId;
-    const { projects } = await apiGetRecentProjects(auth.apiKey, workspaceId, 20).catch(() => ({
-        projects: [],
-    }));
-    if (projects.length > 0) {
-        // Pre-select project whose latest version matches the current branch
-        const currentBranch = gitInfo.branch;
-        const branchMatch = currentBranch
-            ? projects.find((proj) => proj.latestVersion.branch === currentBranch)
-            : undefined;
-        // Move branch-matched project to the top of the list
-        const sortedProjects = branchMatch
-            ? [branchMatch, ...projects.filter((proj) => proj.projectId !== branchMatch.projectId)]
-            : projects;
-        const projectChoice = await scrollableSelect({
-            message: "Create a new project in Inflight, or update an existing one?",
-            maxItems: 5,
-            ...(branchMatch && { initialValue: branchMatch.projectId }),
-            options: [
-                { value: "new", label: "Start a new project" },
-                ...sortedProjects.map((proj) => ({
-                    value: proj.projectId,
-                    label: `"${proj.latestVersion.title}"`,
-                    hint: proj.latestVersion.branch === currentBranch
-                        ? `${formatRelativeTime(proj.latestVersion.createdAt)} · current branch (${currentBranch})`
-                        : formatRelativeTime(proj.latestVersion.createdAt),
-                })),
-            ],
-        });
-        if (p.isCancel(projectChoice)) {
-            p.cancel("Cancelled.");
-            process.exit(0);
+    if (opts.project) {
+        // --project flag provided (agent re-invocation)
+        if (opts.project !== "new") {
+            selectedProjectId = opts.project;
+        }
+    }
+    else {
+        const { projects } = await apiGetRecentProjects(auth.apiKey, workspaceId, 20).catch(() => ({
+            projects: [],
+        }));
+        if (projects.length > 0) {
+            const branchMatches = gitInfo.branch
+                ? projects.filter((proj) => proj.latestVersion.branch === gitInfo.branch)
+                : [];
+            const rest = projects.filter((proj) => !branchMatches.includes(proj));
+            const sorted = [...branchMatches, ...rest];
+            if (isAgent) {
+                agentActionRequired({
+                    type: "choose_project",
+                    message: projects.length > 5
+                        ? "Ask the user which project to share into. Show the first 5 options. If the user wants more, show the rest."
+                        : "Ask the user which project to share into.",
+                    choices: [
+                        { id: "new", label: "Start a new project" },
+                        ...sorted.map((proj) => ({
+                            id: proj.projectId,
+                            label: proj.latestVersion.title,
+                            hint: branchMatches.includes(proj)
+                                ? `${formatRelativeTime(proj.latestVersion.createdAt)} · current branch (${gitInfo.branch})`
+                                : formatRelativeTime(proj.latestVersion.createdAt),
+                        })),
+                    ],
+                    nextCommand: `inflight share --skip-git-check --url ${stagingUrl} --project <ID>`,
+                });
+            }
+            const firstBranchMatch = branchMatches[0];
+            const projectChoice = await scrollableSelect({
+                message: "Create a new project in Inflight, or update an existing one?",
+                maxItems: 5,
+                ...(firstBranchMatch && { initialValue: firstBranchMatch.projectId }),
+                options: [
+                    { value: "new", label: "Start a new project" },
+                    ...sorted.map((proj) => ({
+                        value: proj.projectId,
+                        label: `"${proj.latestVersion.title}"`,
+                        hint: branchMatches.includes(proj)
+                            ? `${formatRelativeTime(proj.latestVersion.createdAt)} · current branch (${gitInfo.branch})`
+                            : formatRelativeTime(proj.latestVersion.createdAt),
+                    })),
+                ],
+            });
+            if (p.isCancel(projectChoice)) {
+                p.cancel("Cancelled.");
+                process.exit(0);
+            }
+            if (projectChoice !== "new") {
+                selectedProjectId = projectChoice;
+            }
         }
-        if (projectChoice !== "new") {
-            selectedProjectId = projectChoice;
-            // Check for override opportunity — only when latest version has no feedback
-            const selectedProject = projects.find((proj) => proj.projectId === selectedProjectId);
-            if (selectedProject && selectedProject.latestVersion.commentCount === 0) {
-                const overrideChoice = await p.select({
-                    message: `"${selectedProject.latestVersion.title}" has no feedback yet.`,
-                    options: [
+    }
+    // ── Step 5: Override check ──
+    if (selectedProjectId && opts.versionMode !== "new") {
+        const { projects } = await apiGetRecentProjects(auth.apiKey, workspaceId, 20).catch(() => ({
+            projects: [],
+        }));
+        const selectedProject = projects.find((proj) => proj.projectId === selectedProjectId);
+        if (opts.versionMode === "override") {
+            if (selectedProject) {
+                overrideVersionId = selectedProject.latestVersion.id;
+            }
+        }
+        else if (selectedProject && selectedProject.latestVersion.commentCount === 0) {
+            // No explicit mode and latest version has no feedback — ask
+            if (isAgent) {
+                agentActionRequired({
+                    type: "choose_override",
+                    message: `"${selectedProject.latestVersion.title}" has no feedback yet. Ask the user whether to update it or create a new version.`,
+                    choices: [
                         {
-                            value: "override",
+                            id: "override",
                             label: "Update its staging URL",
                             hint: `replace with ${new URL(stagingUrl).hostname}`,
                         },
                         {
-                            value: "new_version",
+                            id: "new_version",
                             label: "Add a new version",
                             hint: "keep both in version history",
                         },
                     ],
+                    instructions: {
+                        override: `Re-run with: inflight share --skip-git-check --url ${stagingUrl} --project ${selectedProjectId} --version-mode override`,
+                        new_version: `Re-run with: inflight share --skip-git-check --url ${stagingUrl} --project ${selectedProjectId} --version-mode new`,
+                    },
+                    nextCommand: `inflight share --skip-git-check --url ${stagingUrl} --project ${selectedProjectId} --version-mode <override|new>`,
                 });
-                if (p.isCancel(overrideChoice)) {
-                    p.cancel("Cancelled.");
-                    process.exit(0);
-                }
-                if (overrideChoice === "override") {
-                    overrideVersionId = selectedProject.latestVersion.id;
-                }
+            }
+            const overrideChoice = await p.select({
+                message: `"${selectedProject.latestVersion.title}" has no feedback yet.`,
+                options: [
+                    {
+                        value: "override",
+                        label: "Update its staging URL",
+                        hint: `replace with ${new URL(stagingUrl).hostname}`,
+                    },
+                    {
+                        value: "new_version",
+                        label: "Add a new version",
+                        hint: "keep both in version history",
+                    },
+                ],
+            });
+            if (p.isCancel(overrideChoice)) {
+                p.cancel("Cancelled.");
+                process.exit(0);
+            }
+            if (overrideChoice === "override") {
+                overrideVersionId = selectedProject.latestVersion.id;
             }
         }
     }
+    // ── Step 6: Create version ──
     const result = await apiCreateVersion({
         apiKey: auth.apiKey,
         workspaceId,
@@ -652,9 +563,19 @@ export async function shareCommand(opts = {}) {
         ...(selectedProjectId && { projectId: selectedProjectId }),
         ...(overrideVersionId && { overrideVersionId }),
     }).catch((e) => {
+        if (isAgent)
+            agentError({ type: "create_failed", message: e.message });
         p.log.error(e.message);
         process.exit(1);
     });
+    await open(appendWidgetToken(stagingUrl, result.widgetToken));
+    if (isAgent) {
+        agentSuccess({
+            stagingUrl,
+            ...result,
+            isOverride: !!overrideVersionId,
+        });
+    }
     p.log.info(`Staging URL: ${pc.cyan(stagingUrl)}`);
     if (overrideVersionId) {
         p.outro(pc.green("✓ Staging URL updated") + " — opening in browser...");
@@ -662,5 +583,4 @@ export async function shareCommand(opts = {}) {
     else {
         p.outro(pc.green("✓ Inflight added to your staging URL") + " — opening in browser...");
     }
-    await open(appendWidgetToken(stagingUrl, result.widgetToken));
 }