inflight-cli 2.13.0 → 2.14.0

package/dist/commands/workspace.d.ts

@@ -1,4 +1,3 @@
 export declare function workspaceCommand(opts: {
-    json?: boolean;
-    set?: string;
+    workspace?: string;
 }): Promise<void>;

package/dist/commands/workspace.js

@@ -2,76 +2,76 @@ import * as p from "@clack/prompts";
 import pc from "picocolors";
 import { readGlobalAuth, readWorkspaceConfig, writeWorkspaceConfig } from "../lib/config.js";
 import { apiGetMe } from "../lib/api.js";
+import { isAgent, agentError, agentActionRequired, agentSuccess } from "../lib/agent.js";
 export async function workspaceCommand(opts) {
     const auth = readGlobalAuth();
     if (!auth) {
-        if (opts.json) {
-            console.log(JSON.stringify({ error: "not_authenticated", message: "Not logged in. Run inflight login first." }));
-            process.exit(1);
+        if (isAgent) {
+            agentError({
+                type: "not_authenticated",
+                message: "Not logged in. Run inflight setup first.",
+                suggestion: "inflight setup",
+            });
         }
-        p.log.error("Not logged in. Run " + pc.cyan("inflight login") + " first.");
+        p.log.error("Not logged in. Run " + pc.cyan("inflight setup") + " first.");
         process.exit(1);
     }
-    // ── Fetch workspaces ──
     const me = await apiGetMe(auth.apiKey).catch((e) => {
-        if (opts.json) {
-            console.log(JSON.stringify({ error: "api_error", message: e.message }));
-            process.exit(1);
-        }
+        if (isAgent)
+            agentError({ type: "api_error", message: e.message });
         p.log.error(e.message);
         process.exit(1);
     });
     const workspaces = me.workspaces;
-    // ── Set active workspace ──
-    if (opts.set) {
-        const workspace = workspaces.find((w) => w.id === opts.set);
-        if (!workspace) {
-            const msg = `Workspace '${opts.set}' not found.`;
-            if (opts.json) {
-                console.log(JSON.stringify({
-                    error: "workspace_not_found",
-                    message: msg,
-                    available: workspaces.map((w) => ({ id: w.id, name: w.name })),
-                }));
-            }
-            else {
-                p.log.error(msg);
+    if (workspaces.length === 0) {
+        if (isAgent) {
+            agentError({ type: "no_workspaces", message: "No workspaces found. Create one at inflight.co first." });
+        }
+        p.log.error("No workspaces found. Create one at " + pc.cyan("inflight.co") + " first.");
+        process.exit(1);
+    }
+    const currentId = readWorkspaceConfig()?.workspaceId;
+    // --workspace flag: set directly
+    if (opts.workspace) {
+        const match = workspaces.find((w) => w.id === opts.workspace);
+        if (!match) {
+            if (isAgent) {
+                agentError({
+                    type: "invalid_workspace",
+                    message: `Workspace "${opts.workspace}" not found.`,
+                    suggestion: `Valid IDs: ${workspaces.map((w) => w.id).join(", ")}`,
+                });
             }
+            p.log.error(`Workspace "${opts.workspace}" not found.`);
             process.exit(1);
         }
-        writeWorkspaceConfig({ workspaceId: workspace.id });
-        if (opts.json) {
-            console.log(JSON.stringify({ success: true, active: workspace.id, name: workspace.name }));
+        writeWorkspaceConfig({ workspaceId: match.id });
+        if (isAgent) {
+            agentSuccess({ workspaceId: match.id, name: match.name });
         }
-        else {
-            p.outro(pc.green(`Workspace set to ${pc.bold(workspace.name)}`));
-        }
-        return;
-    }
-    // ── JSON mode: list + active ──
-    if (opts.json) {
-        const active = readWorkspaceConfig()?.workspaceId ?? null;
-        console.log(JSON.stringify({ active, workspaces }));
+        p.outro(pc.green(`Workspace set to ${pc.bold(match.name)}`));
         return;
     }
-    // ── Interactive mode: select workspace ──
-    if (workspaces.length === 0) {
-        p.log.error("No workspaces found. Create one at inflight.co");
-        process.exit(1);
-    }
-    const currentWorkspaceId = readWorkspaceConfig()?.workspaceId;
-    if (currentWorkspaceId) {
-        const currentWs = workspaces.find((w) => w.id === currentWorkspaceId);
-        if (currentWs) {
-            p.log.info(`Current workspace: ${pc.bold(currentWs.name)}`);
-        }
+    // Agent mode: always present choices
+    if (isAgent) {
+        agentActionRequired({
+            type: "choose_workspace",
+            message: "Ask the user which workspace to use.",
+            choices: workspaces.map((w) => ({
+                id: w.id,
+                label: w.name,
+                hint: w.id === currentId ? "current" : undefined,
+            })),
+            nextCommand: "inflight workspace --workspace <ID>",
+        });
     }
+    // Interactive: always show picker
     const selected = await p.select({
         message: "Select a workspace",
         options: workspaces.map((w) => ({
             value: w.id,
             label: w.name,
-            hint: currentWorkspaceId === w.id ? "current" : undefined,
+            hint: w.id === currentId ? "current" : undefined,
         })),
     });
     if (p.isCancel(selected)) {

package/dist/index.js

@@ -8,8 +8,6 @@ import { shareCommand } from "./commands/share.js";
 import { logoutCommand } from "./commands/logout.js";
 import { resetCommand } from "./commands/reset.js";
 import { workspaceCommand } from "./commands/workspace.js";
-import { registerVercelCommand } from "./commands/vercel.js";
-import { registerNetlifyCommand } from "./commands/netlify.js";
 import { setupCommand } from "./commands/setup.js";
 import pkg from "../package.json" with { type: "json" };
 const { version } = pkg;
@@ -53,18 +51,14 @@ program
     .option("--workspace <id>", "Workspace ID (skip selection)")
     .option("--project <id>", "Project ID, or 'new' to create")
     .option("--provider <id>", "Deployment provider: vercel, netlify")
-    .option("--deployment <url>", "Specific deployment URL")
     .option("--version-mode <mode>", "Version handling: 'override' or 'new'")
     .option("--skip-git-check", "Skip git state check (use after agent handled git)")
     .action((opts) => shareCommand(opts));
 program
     .command("workspace")
     .description("Get or set your active workspace")
-    .option("--json", "Output as JSON")
-    .option("--set <id>", "Set the active workspace")
+    .option("--workspace <id>", "Workspace ID (skip selection)")
     .action((opts) => workspaceCommand(opts));
-registerVercelCommand(program);
-registerNetlifyCommand(program);
 program.command("logout").description("Disconnect your Inflight account").action(logoutCommand);
 program.command("reset").description("Clear all Inflight auth and config").action(resetCommand);
 program.parse();

package/dist/lib/git.d.ts

@@ -1,8 +1,8 @@
 export interface GitInfo {
     branch: string | null;
-    commitShort: string | null;
-    commitFull: string | null;
-    commitMessage: string | null;
+    commitShort: string;
+    commitFull: string;
+    commitMessage: string;
     remoteUrl: string | null;
     isDirty: boolean;
     diff: string | null;
@@ -38,23 +38,29 @@ export declare function parseDiffStat(diffStat: string): Array<{
     insertions: number;
     deletions: number;
 }>;
-export declare function getGitInfo(cwd: string): GitInfo;
+export declare function getGitInfo(cwd: string): GitInfo | null;
 export declare function isGitRepo(cwd: string): boolean;
 /** Returns the root directory of the git repo, or null if not in one. */
 export declare function getGitRoot(cwd: string): string | null;
-export interface GitSyncState {
-    /** "clean" = nothing to do, "uncommitted" = dirty working tree, "unpushed" = clean but commits not pushed, "no_remote" = branch has never been pushed */
-    status: "clean" | "uncommitted" | "unpushed" | "no_remote" | "detached";
-    /** Short file status lines from `git status --porcelain` (only when uncommitted) */
+export type GitSyncState = {
+    status: "clean";
+} | {
+    status: "detached";
+} | {
+    status: "uncommitted";
+    branch: string;
     changedFiles: string[];
-    /** Unpushed commit summary lines: "abc1234 commit message" (only when unpushed) */
+} | {
+    status: "unpushed";
+    branch: string;
     unpushedCommits: string[];
-    /** Current branch name (null if detached) */
-    branch: string | null;
-}
+} | {
+    status: "no_remote";
+    branch: string;
+};
 /**
  * Determines whether the local repo has changes that haven't been deployed.
- * Priority: detached > uncommitted > unpushed > no_remote > clean
+ * Priority: detached > uncommitted > no_remote > unpushed > clean
  */
 export declare function getGitSyncState(cwd: string): GitSyncState;
 /**
@@ -63,7 +69,7 @@ export declare function getGitSyncState(cwd: string): GitSyncState;
  * "fix-header-alignment"   → "Update header alignment"
  * "main"                   → "Update main"
  */
-export declare function generateCommitMessage(branch: string | null): string;
+export declare function generateCommitMessage(branch: string): string;
 /**
  * Stages all changes, commits with the given message, and pushes.
  * Uses `git add -A` (tracked + untracked — .gitignore handles exclusions).

package/dist/lib/git.js

@@ -222,23 +222,15 @@ export function parseDiffStat(diffStat) {
     })
         .filter((entry) => entry !== null);
 }
-const EMPTY_GIT_INFO = {
-    branch: null,
-    commitShort: null,
-    commitFull: null,
-    commitMessage: null,
-    remoteUrl: null,
-    isDirty: false,
-    diff: null,
-};
 export function getGitInfo(cwd) {
     if (!isGitRepo(cwd))
-        return EMPTY_GIT_INFO;
+        return null;
+    const rawBranch = run("git rev-parse --abbrev-ref HEAD", cwd);
     return {
-        branch: run("git rev-parse --abbrev-ref HEAD", cwd),
-        commitShort: run("git rev-parse --short HEAD", cwd),
-        commitFull: run("git rev-parse HEAD", cwd),
-        commitMessage: run("git log -1 --pretty=%s", cwd),
+        branch: rawBranch === "HEAD" ? null : rawBranch,
+        commitShort: run("git rev-parse --short HEAD", cwd) ?? "",
+        commitFull: run("git rev-parse HEAD", cwd) ?? "",
+        commitMessage: run("git log -1 --pretty=%s", cwd) ?? "",
         remoteUrl: run("git remote get-url origin", cwd),
         isDirty: run("git status --porcelain", cwd) !== "",
         diff: getDiff(cwd),
@@ -253,36 +245,32 @@ export function getGitRoot(cwd) {
 }
 /**
  * Determines whether the local repo has changes that haven't been deployed.
- * Priority: detached > uncommitted > unpushed > no_remote > clean
+ * Priority: detached > uncommitted > no_remote > unpushed > clean
  */
 export function getGitSyncState(cwd) {
     const branch = run("git rev-parse --abbrev-ref HEAD", cwd);
     // Detached HEAD — can't push meaningfully
     if (!branch || branch === "HEAD") {
-        return { status: "detached", changedFiles: [], unpushedCommits: [], branch: null };
-    }
-    // No origin remote — can't push anywhere
-    if (!run("git remote get-url origin", cwd)) {
-        return { status: "clean", changedFiles: [], unpushedCommits: [], branch };
+        return { status: "detached" };
     }
     // Check for uncommitted changes (staged + unstaged + untracked)
     const porcelain = run("git status --porcelain", cwd) ?? "";
-    const changedFiles = porcelain.split("\n").filter((l) => l.trim().length > 0);
-    if (changedFiles.length > 0) {
-        return { status: "uncommitted", changedFiles, unpushedCommits: [], branch };
+    if (porcelain.length > 0) {
+        const changedFiles = porcelain.split("\n").filter((l) => l.trim().length > 0);
+        return { status: "uncommitted", branch, changedFiles };
     }
     // Check if branch has a remote tracking branch
     const upstream = run(`git rev-parse --abbrev-ref ${branch}@{upstream}`, cwd);
     if (!upstream) {
-        return { status: "no_remote", changedFiles: [], unpushedCommits: [], branch };
+        return { status: "no_remote", branch };
     }
     // Check for unpushed commits
     const log = run(`git log ${upstream}..HEAD --oneline`, cwd) ?? "";
     if (log.length > 0) {
         const unpushedCommits = log.split("\n").filter((l) => l.trim().length > 0);
-        return { status: "unpushed", changedFiles: [], unpushedCommits, branch };
+        return { status: "unpushed", branch, unpushedCommits };
     }
-    return { status: "clean", changedFiles: [], unpushedCommits: [], branch };
+    return { status: "clean" };
 }
 /**
  * Auto-generates a short commit message from the branch name.
@@ -291,8 +279,6 @@ export function getGitSyncState(cwd) {
  * "main"                   → "Update main"
  */
 export function generateCommitMessage(branch) {
-    if (!branch)
-        return "Update changes";
     // Strip common prefixes: feature/, fix/, feat/, chore/, etc.
     const stripped = branch.replace(/^(feature|fix|feat|chore|bugfix|hotfix|release)\/?/i, "");
     const humanized = (stripped || branch).replace(/[-_/]/g, " ").replace(/\s+/g, " ").trim();

package/dist/lib/netlify.d.ts

@@ -51,17 +51,16 @@ export interface NetlifyDeploy {
     context: string;
     createdAt: number;
 }
-export declare function getNetlifyUser(token: string): Promise<{
-    id: string;
-    name: string;
-    email: string;
-} | null>;
 export declare function getNetlifySites(token: string): Promise<NetlifySite[]>;
 export declare function getNetlifySiteById(token: string, siteId: string): Promise<NetlifySite | null>;
 export declare function getNetlifyDeploys(token: string, siteId: string, siteName: string, opts?: {
     branch?: string;
     limit?: number;
 }): Promise<NetlifyDeploy[]>;
+/**
+ * Fetches a single deploy by ID.
+ */
+export declare function getNetlifyDeployById(token: string, deployId: string, siteName: string): Promise<NetlifyDeploy | null>;
 /**
  * Matches Netlify sites against a git remote's owner/repo.
  * Compares build_settings.repo_path against "owner/repo".

package/dist/lib/netlify.js

@@ -128,15 +128,6 @@ export function writeLocalNetlifySite(root, siteId) {
 }
 // --- API calls (all take token explicitly) ---
 const NETLIFY_API = "https://api.netlify.com/api/v1";
-export async function getNetlifyUser(token) {
-    const res = await fetch(`${NETLIFY_API}/user`, {
-        headers: { Authorization: `Bearer ${token}` },
-    });
-    if (!res.ok)
-        return null;
-    const data = (await res.json());
-    return { id: data.id, name: data.full_name, email: data.email };
-}
 export async function getNetlifySites(token) {
     const all = [];
     let page = 1;
@@ -179,7 +170,7 @@ export async function getNetlifyDeploys(token, siteId, siteName, opts) {
         id: d.id,
         state: d.state,
         branch: d.branch,
-        commitRef: d.commit_ref?.slice(0, 7) ?? null,
+        commitRef: d.commit_ref ?? null,
         commitMessage: d.title,
         // Construct the immutable per-deploy permalink
         deploySslUrl: `https://${d.id}--${siteName}.netlify.app`,
@@ -187,6 +178,27 @@ export async function getNetlifyDeploys(token, siteId, siteName, opts) {
         createdAt: new Date(d.created_at).getTime(),
     }));
 }
+/**
+ * Fetches a single deploy by ID.
+ */
+export async function getNetlifyDeployById(token, deployId, siteName) {
+    const res = await fetch(`${NETLIFY_API}/deploys/${encodeURIComponent(deployId)}`, {
+        headers: { Authorization: `Bearer ${token}` },
+    });
+    if (!res.ok)
+        return null;
+    const d = (await res.json());
+    return {
+        id: d.id,
+        state: d.state,
+        branch: d.branch,
+        commitRef: d.commit_ref ?? null,
+        commitMessage: d.title,
+        deploySslUrl: `https://${d.id}--${siteName}.netlify.app`,
+        context: d.context,
+        createdAt: new Date(d.created_at).getTime(),
+    };
+}
 /**
  * Matches Netlify sites against a git remote's owner/repo.
  * Compares build_settings.repo_path against "owner/repo".

package/dist/lib/vercel.d.ts

@@ -45,6 +45,7 @@ export interface VercelProject {
     };
 }
 export interface VercelDeployment {
+    id: string;
     url: string;
     state: string;
     branch: string | null;
@@ -70,20 +71,16 @@ export declare function matchVercelProjectsByRepo(projects: VercelProject[], git
  * Creates a new Vercel project linked to a git repository.
  */
 export declare function createVercelProject(token: string, teamId: string, name: string, repo: string, repoType: "github" | "gitlab" | "bitbucket"): Promise<VercelProject>;
-/**
- * Fetches the branch alias URL (stable, auto-updates with each push).
- * Returns null if no deployment exists for this branch.
- */
-export interface BranchAlias {
-    url: string;
-    state: string;
-}
-export declare function getBranchAlias(token: string, teamId: string, projectId: string, branch: string | null): Promise<BranchAlias | null>;
 /**
  * Fetches recent deployments for a project.
  */
 export declare function getVercelDeployments(token: string, teamId: string, projectId: string, opts?: {
     limit?: number;
     branch?: string;
+    sha?: string;
 }): Promise<VercelDeployment[]>;
+/**
+ * Fetches a single deployment by ID.
+ */
+export declare function getVercelDeploymentById(token: string, deploymentId: string, teamId: string): Promise<VercelDeployment | null>;
 export {};

package/dist/lib/vercel.js

@@ -222,37 +222,6 @@ export async function createVercelProject(token, teamId, name, repo, repoType) {
     const data = (await res.json());
     return { id: data.id, name: data.name, teamId };
 }
-export async function getBranchAlias(token, teamId, projectId, branch) {
-    if (!branch)
-        return null;
-    const params = new URLSearchParams({
-        projectId,
-        teamId,
-        limit: "1",
-        branch,
-    });
-    const res = await fetch(`https://api.vercel.com/v6/deployments?${params}`, {
-        headers: { Authorization: `Bearer ${token}` },
-    });
-    if (!res.ok)
-        return null;
-    const data = (await res.json());
-    const deploy = data.deployments[0];
-    if (!deploy)
-        return null;
-    // Fetch the automatic alias for this deployment
-    const aliasParams = new URLSearchParams({ teamId });
-    const aliasRes = await fetch(`https://api.vercel.com/v13/deployments/${deploy.uid}?${aliasParams}`, {
-        headers: { Authorization: `Bearer ${token}` },
-    });
-    if (!aliasRes.ok)
-        return null;
-    const aliasData = (await aliasRes.json());
-    const url = aliasData.automaticAliases?.[0];
-    if (!url)
-        return null;
-    return { url, state: deploy.state };
-}
 /**
  * Fetches recent deployments for a project.
  */
@@ -265,6 +234,9 @@ export async function getVercelDeployments(token, teamId, projectId, opts) {
     if (opts?.branch) {
         params.set("branch", opts.branch);
     }
+    if (opts?.sha) {
+        params.set("sha", opts.sha);
+    }
     const res = await fetch(`https://api.vercel.com/v6/deployments?${params}`, {
         headers: { Authorization: `Bearer ${token}` },
     });
@@ -272,12 +244,33 @@ export async function getVercelDeployments(token, teamId, projectId, opts) {
         return [];
     const data = (await res.json());
     return data.deployments.map((d) => ({
+        id: d.uid,
         url: d.url,
         state: d.state,
         branch: d.meta?.githubCommitRef ?? d.meta?.gitlabCommitRef ?? d.meta?.bitbucketCommitRef ?? null,
-        commitSha: (d.meta?.githubCommitSha ?? d.meta?.gitlabCommitSha ?? d.meta?.bitbucketCommitSha ?? null)?.slice(0, 7) ??
-            null,
+        commitSha: d.meta?.githubCommitSha ?? d.meta?.gitlabCommitSha ?? d.meta?.bitbucketCommitSha ?? null,
         commitMessage: d.meta?.githubCommitMessage ?? d.meta?.gitlabCommitMessage ?? d.meta?.bitbucketCommitMessage ?? null,
         createdAt: d.created,
     }));
 }
+/**
+ * Fetches a single deployment by ID.
+ */
+export async function getVercelDeploymentById(token, deploymentId, teamId) {
+    const params = new URLSearchParams({ teamId });
+    const res = await fetch(`https://api.vercel.com/v13/deployments/${encodeURIComponent(deploymentId)}?${params}`, {
+        headers: { Authorization: `Bearer ${token}` },
+    });
+    if (!res.ok)
+        return null;
+    const d = (await res.json());
+    return {
+        id: d.uid,
+        url: d.url,
+        state: d.status,
+        branch: d.meta?.githubCommitRef ?? d.meta?.gitlabCommitRef ?? d.meta?.bitbucketCommitRef ?? null,
+        commitSha: d.meta?.githubCommitSha ?? d.meta?.gitlabCommitSha ?? d.meta?.bitbucketCommitSha ?? null,
+        commitMessage: d.meta?.githubCommitMessage ?? d.meta?.gitlabCommitMessage ?? d.meta?.bitbucketCommitMessage ?? null,
+        createdAt: d.created,
+    };
+}

package/dist/providers/index.d.ts

@@ -6,6 +6,6 @@ export interface ProviderResolveOptions {
 export interface Provider {
     id: string;
     label: string;
-    resolve: (cwd: string, gitInfo: GitInfo, opts?: ProviderResolveOptions) => Promise<string | null>;
+    resolve: (gitRoot: string, gitInfo: GitInfo, opts?: ProviderResolveOptions) => Promise<string | null>;
 }
 export declare const providers: Provider[];

package/dist/providers/index.js

@@ -1,6 +1,13 @@
 import { resolveNetlifyUrl } from "./netlify.js";
 import { resolveVercelUrl } from "./vercel.js";
-export const providers = [
-    { id: "vercel", label: "Vercel", resolve: resolveVercelUrl },
-    { id: "netlify", label: "Netlify", resolve: resolveNetlifyUrl },
-];
+const VercelProvider = {
+    id: "vercel",
+    label: "Vercel",
+    resolve: resolveVercelUrl,
+};
+const NetlifyProvider = {
+    id: "netlify",
+    label: "Netlify",
+    resolve: resolveNetlifyUrl,
+};
+export const providers = [VercelProvider, NetlifyProvider];

package/dist/providers/netlify.d.ts

@@ -1,5 +1,3 @@
 import type { GitInfo } from "../lib/git.js";
 import type { ProviderResolveOptions } from "./index.js";
-import type { NetlifyConfig } from "../lib/config.js";
-export declare function pickNetlifySite(token: string): Promise<NetlifyConfig | null>;
-export declare function resolveNetlifyUrl(cwd: string, gitInfo: GitInfo, opts?: ProviderResolveOptions): Promise<string | null>;
+export declare function resolveNetlifyUrl(gitRoot: string, gitInfo: GitInfo, opts?: ProviderResolveOptions): Promise<string | null>;