@cargo-ai/cli 1.0.113 → 1.0.115

package/README.md

@@ -51,7 +51,7 @@ Using a coding agent? Skip the manual setup — see [Agent Skills](#agent-skills
 
 ## Authentication
 
-A single `cargo-ai login` command supports three channels — pass exactly one of `--email`, `--oauth` or `--token`:
+A single `cargo-ai login` command supports four channels — pass exactly one of `--email`, `--oauth`, `--agentid` or `--token`:
 
 ```bash
 # 1. Sign in with a code emailed to you, no browser needed
@@ -60,13 +60,16 @@ cargo-ai login --email you@company.com
 # 2. Sign in via your browser using the OAuth 2.0 Device Authorization Flow
 cargo-ai login --oauth
 
-# 3. Sign in with an API token you already have
+# 3. Sign an agent in through AgentID
+cargo-ai login --agentid
+
+# 4. Sign in with an API token you already have
 cargo-ai login --token <your-api-token>
 ```
 
-`--email` and `--oauth` both create the account if it does not exist yet, so there is no separate sign-up command.
+`--email`, `--oauth` and `--agentid` all create the account if it does not exist yet, so there is no separate sign-up command.
 
-`--email` and `--oauth` save the signed-in session — a short-lived access token plus the refresh token that renews it — to `~/.config/cargo-ai/credentials.json` (file mode `0600`). The CLI renews it in the background as it expires, so you stay signed in and no API token is created per machine. `--token` saves the API token you supplied instead. The same file backs `cargo-cdk`, so one login serves both.
+`--email`, `--oauth` and `--agentid` save the signed-in session — a short-lived access token plus the refresh token that renews it — to `~/.config/cargo-ai/credentials.json` (file mode `0600`). The CLI renews it in the background as it expires, so you stay signed in and no API token is created per machine. `--token` saves the API token you supplied instead. The same file backs `cargo-cdk`, so one login serves both.
 
 `cargo-ai logout` revokes the session at the identity provider, so signing out is final. A token you supplied yourself with `--token` is only forgotten locally, since it may be in use elsewhere; pass `--keep-token` to force that behaviour for a session too. If a credentials file cannot be deleted — a read-only config directory, or one owned by another user — `logout` fails and names the file rather than reporting a sign-out the next command would contradict.
 
@@ -114,9 +117,23 @@ echo 123456 | cargo-ai login --email you@company.com --code -
 
 The CLI ships with a built-in OAuth client, so no setup is required.
 
+### AgentID sign-in (`--agentid`)
+
+`cargo-ai login --agentid` signs an agent in as itself, through the same AgentID connection the web app offers. It does not open the Cargo app.
+
+The command prints an Auth0 authorize URL (`connection=agentid`) and listens on `http://127.0.0.1` for the redirect. Open that URL once. A second visit starts a different sign-in. Auth0 sends the browser to `https://auth.agentid.com`. When that page shows an auth token, approve it within 5 minutes:
+
+```bash
+agentmail inboxes authorize --inbox-id <inbox> --auth-token <token> --accept-disclosure true
+```
+
+AgentID then redirects back to the CLI, which writes the session the same way `--email` and `--oauth` do. A browser that already has an AgentID session for that inbox continues without the token step.
+
+The cargo-ai application in Auth0 has to list `http://127.0.0.1:52701/callback` under Allowed Callback URLs, and have the AgentID connection enabled. Auth0 does not accept a wildcard port, so the CLI always uses this one. Until that URL is allowed, the command stops immediately and says so.
+
 ### Workspace selection
 
-`--email` and `--oauth` authenticate you as a user, so the CLI picks a workspace to save alongside the session:
+`--email`, `--oauth` and `--agentid` authenticate you as a user, so the CLI picks a workspace to save alongside the session:
 
 - **No workspaces**: one is created (you are prompted for a name in a TTY, or pass `--workspace-name <name>`).
 - **One workspace**: it is selected automatically.

package/build/commands/auth/agentId.d.ts

@@ -0,0 +1,67 @@
+import { type IdentityTokens } from "./auth0.js";
+/** Auth0 connection name. Matches the web sign-in button. */
+export declare const AGENTID_CONNECTION = "agentid";
+/**
+ * Auth0 refuses a wildcard port in Allowed Callback URLs, so the CLI always
+ * listens here. The cargo-ai application must allow this exact URL.
+ */
+export declare const AGENTID_CALLBACK_PORT = 52701;
+export declare function loopbackRedirectUri(port: number): string;
+export declare const AGENTID_CALLBACK_URL: string;
+export declare function buildAgentIdAuthorizeUrl(opts: {
+    domain: string;
+    clientId: string;
+    audience: string;
+    scope: string;
+    redirectUri: string;
+    state: string;
+    codeChallenge: string;
+}): string;
+export type AuthorizeCheck = {
+    ok: true;
+} | {
+    ok: false;
+    message: string;
+};
+/**
+ * The device-code flow cannot name a connection, so AgentID sign-in starts
+ * with a normal authorize request and a loopback redirect. Auth0 answers that
+ * request before any browser work; a callback that is not allowed, or a
+ * connection that is off, fails here instead of after a five-minute wait.
+ *
+ * A started sign-in looks like exactly one thing: a redirect away from the
+ * Auth0 domain, to AgentID. A page served from Auth0 itself — universal login,
+ * an error — means the sign-in never left for AgentID.
+ */
+export declare function classifyAuthorizeResponse(opts: {
+    domain: string;
+    status: number;
+    location: string | null;
+    body: string;
+}): AuthorizeCheck;
+export type CallbackResult = {
+    code: string;
+} | {
+    error: string;
+};
+export declare function readCallbackResult(search: string): CallbackResult;
+/**
+ * Only a browser navigation that carries this login's `state` and the
+ * authorization result may end the wait. The callback port is fixed and
+ * documented, so anything else that reaches it — a probe, a preflight, a
+ * cross-site request, a redirect left over from an earlier run — has to leave
+ * the listener up rather than settle the wait and fail the sign-in. Auth0
+ * returns `state` on error redirects too, so a denial still gets through.
+ */
+export declare function isSignInCallback(method: string, search: string, expectedState: string): boolean;
+/**
+ * Signs in through the AgentID Auth0 connection and returns the same session
+ * tokens the other channels hand to `establishSession`.
+ *
+ * The command prints an authorize URL on Auth0. Opening it lands on
+ * auth.agentid.com, never on the Cargo app. The agent approves the auth token
+ * shown on that page with `agentmail inboxes authorize`. AgentID then redirects
+ * back to a localhost port this process is listening on.
+ */
+export declare function runAgentIdLogin(): Promise<IdentityTokens>;
+//# sourceMappingURL=agentId.d.ts.map

package/build/commands/auth/agentId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentId.d.ts","sourceRoot":"","sources":["../../../src/commands/auth/agentId.ts"],"names":[],"mappings":"AASA,OAAO,EAEL,KAAK,cAAc,EAKpB,MAAM,YAAY,CAAC;AAEpB,6DAA6D;AAC7D,eAAO,MAAM,kBAAkB,YAAY,CAAC;AAO5C;;;GAGG;AACH,eAAO,MAAM,qBAAqB,QAAQ,CAAC;AAE3C,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAExD;AAED,eAAO,MAAM,oBAAoB,QAA6C,CAAC;AAE/E,wBAAgB,wBAAwB,CAAC,IAAI,EAAE;IAC7C,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,MAAM,CAAC;CACvB,GAAG,MAAM,CAcT;AAED,MAAM,MAAM,cAAc,GAAG;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAS3E;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE;IAC9C,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,cAAc,CA6BjB;AAgCD,MAAM,MAAM,cAAc,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAElE,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,CAmBjE;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,MAAM,GACpB,OAAO,CAcT;AAED;;;;;;;;GAQG;AACH,wBAAsB,eAAe,IAAI,OAAO,CAAC,cAAc,CAAC,CAkE/D"}

package/build/commands/auth/agentId.js

@@ -0,0 +1,332 @@
+import { createHash, randomBytes } from "node:crypto";
+import { createServer, } from "node:http";
+import { getOAuthConfig } from "../../oauthConfig.js";
+import { failWith, info } from "../runHandler.js";
+import { describeError, parseTokenResponse, postToAuth0, readErrorBody, USER_AGENT, } from "./auth0.js";
+/** Auth0 connection name. Matches the web sign-in button. */
+export const AGENTID_CONNECTION = "agentid";
+/** AgentID drops the waiting page after five minutes. */
+const SIGN_IN_TIMEOUT_MS = 5 * 60 * 1000;
+const CALLBACK_PATH = "/callback";
+/**
+ * Auth0 refuses a wildcard port in Allowed Callback URLs, so the CLI always
+ * listens here. The cargo-ai application must allow this exact URL.
+ */
+export const AGENTID_CALLBACK_PORT = 52701;
+export function loopbackRedirectUri(port) {
+    return `http://127.0.0.1:${String(port)}${CALLBACK_PATH}`;
+}
+export const AGENTID_CALLBACK_URL = loopbackRedirectUri(AGENTID_CALLBACK_PORT);
+export function buildAgentIdAuthorizeUrl(opts) {
+    const params = new URLSearchParams({
+        response_type: "code",
+        client_id: opts.clientId,
+        redirect_uri: opts.redirectUri,
+        scope: opts.scope,
+        audience: opts.audience,
+        connection: AGENTID_CONNECTION,
+        state: opts.state,
+        code_challenge: opts.codeChallenge,
+        code_challenge_method: "S256",
+    });
+    return `https://${opts.domain}/authorize?${params.toString()}`;
+}
+/**
+ * Auth0 sent the request to its own universal login page. That page is the
+ * Cargo sign-in form, which an agent cannot complete, so the connection never
+ * took effect.
+ */
+const CONNECTION_NOT_APPLIED = `Auth0 answered with its own sign-in page instead of handing the request to AgentID, so the "${AGENTID_CONNECTION}" connection did not take effect. Enable it on the cargo-ai Auth0 application, then try again.`;
+/**
+ * The device-code flow cannot name a connection, so AgentID sign-in starts
+ * with a normal authorize request and a loopback redirect. Auth0 answers that
+ * request before any browser work; a callback that is not allowed, or a
+ * connection that is off, fails here instead of after a five-minute wait.
+ *
+ * A started sign-in looks like exactly one thing: a redirect away from the
+ * Auth0 domain, to AgentID. A page served from Auth0 itself — universal login,
+ * an error — means the sign-in never left for AgentID.
+ */
+export function classifyAuthorizeResponse(opts) {
+    if (opts.body.includes("Callback URL mismatch") === true) {
+        return {
+            ok: false,
+            message: `Auth0 rejected the CLI callback (${AGENTID_CALLBACK_URL}). On the cargo-ai Auth0 application, add that exact URL to Allowed Callback URLs and enable the AgentID connection, then try again.`,
+        };
+    }
+    if (opts.status >= 300 && opts.status < 400 && opts.location !== null) {
+        return classifyRedirect(opts.domain, opts.location);
+    }
+    const detail = htmlError(opts.body);
+    if (detail !== undefined) {
+        return {
+            ok: false,
+            message: `Auth0 refused to start AgentID sign-in: ${detail}`,
+        };
+    }
+    if (opts.status >= 200 && opts.status < 300) {
+        return { ok: false, message: CONNECTION_NOT_APPLIED };
+    }
+    return {
+        ok: false,
+        message: `Auth0 refused to start AgentID sign-in: HTTP ${String(opts.status)}`,
+    };
+}
+function classifyRedirect(domain, location) {
+    let url;
+    try {
+        url = new URL(location, `https://${domain}`);
+    }
+    catch {
+        return {
+            ok: false,
+            message: `Auth0 answered the AgentID sign-in request with a redirect the CLI could not read (${location}).`,
+        };
+    }
+    const error = url.searchParams.get("error");
+    if (error !== null) {
+        const description = url.searchParams.get("error_description");
+        return {
+            ok: false,
+            message: `Auth0 refused to start AgentID sign-in: ${description !== null ? description : error}`,
+        };
+    }
+    if (url.host === domain) {
+        return { ok: false, message: CONNECTION_NOT_APPLIED };
+    }
+    return { ok: true };
+}
+export function readCallbackResult(search) {
+    const params = new URLSearchParams(search.startsWith("?") === true ? search.slice(1) : search);
+    const error = params.get("error");
+    if (error !== null) {
+        const description = params.get("error_description");
+        return { error: description !== null ? description : error };
+    }
+    const code = params.get("code");
+    if (code === null) {
+        return { error: "The sign-in redirect did not include a code." };
+    }
+    return { code };
+}
+/**
+ * Only a browser navigation that carries this login's `state` and the
+ * authorization result may end the wait. The callback port is fixed and
+ * documented, so anything else that reaches it — a probe, a preflight, a
+ * cross-site request, a redirect left over from an earlier run — has to leave
+ * the listener up rather than settle the wait and fail the sign-in. Auth0
+ * returns `state` on error redirects too, so a denial still gets through.
+ */
+export function isSignInCallback(method, search, expectedState) {
+    if (method !== "GET") {
+        return false;
+    }
+    const params = new URLSearchParams(search.startsWith("?") === true ? search.slice(1) : search);
+    if (params.get("state") !== expectedState) {
+        return false;
+    }
+    return params.get("error") !== null || params.get("code") !== null;
+}
+/**
+ * Signs in through the AgentID Auth0 connection and returns the same session
+ * tokens the other channels hand to `establishSession`.
+ *
+ * The command prints an authorize URL on Auth0. Opening it lands on
+ * auth.agentid.com, never on the Cargo app. The agent approves the auth token
+ * shown on that page with `agentmail inboxes authorize`. AgentID then redirects
+ * back to a localhost port this process is listening on.
+ */
+export async function runAgentIdLogin() {
+    const config = getOAuthConfig();
+    const state = randomBytes(16).toString("base64url");
+    const verifier = randomBytes(32).toString("base64url");
+    const challenge = createHash("sha256").update(verifier).digest("base64url");
+    let listener;
+    try {
+        listener = await listenForCallback(state);
+    }
+    catch (error) {
+        failWith(error instanceof Error ? error.message : String(error));
+    }
+    try {
+        const redirectUri = loopbackRedirectUri(listener.port);
+        const authorizeUrl = buildAgentIdAuthorizeUrl({
+            domain: config.domain,
+            clientId: config.clientId,
+            audience: config.audience,
+            scope: config.scope,
+            redirectUri,
+            state,
+            codeChallenge: challenge,
+        });
+        await assertAuthorizeStarts({ authorizeUrl, domain: config.domain });
+        info([
+            "",
+            "To sign in with AgentID, open this URL once. It goes to Auth0 and then AgentID, not the Cargo app:",
+            `  ${authorizeUrl}`,
+            "",
+            "Open it only once. A second visit starts a different AgentID sign-in, and approving that one does not finish this command.",
+            "",
+            "If that page shows an auth token, approve it within 5 minutes:",
+            "  agentmail inboxes authorize --inbox-id <inbox> --auth-token <token> --accept-disclosure true",
+            "",
+            "Waiting for that page to redirect back here...",
+            "",
+        ].join("\n"));
+        let callback;
+        try {
+            callback = await listener.done;
+        }
+        catch (error) {
+            failWith(error instanceof Error ? error.message : String(error));
+        }
+        const result = readCallbackResult(callback);
+        if ("error" in result) {
+            failWith(`AgentID sign-in failed: ${result.error}`);
+        }
+        return await exchangeAuthorizationCode({
+            code: result.code,
+            redirectUri,
+            codeVerifier: verifier,
+        });
+    }
+    finally {
+        listener.close();
+    }
+}
+async function assertAuthorizeStarts(opts) {
+    let response;
+    try {
+        response = await fetch(opts.authorizeUrl, {
+            method: "GET",
+            redirect: "manual",
+            headers: { "user-agent": USER_AGENT },
+            signal: AbortSignal.timeout(15_000),
+        });
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        failWith(`Could not reach Auth0 to start AgentID sign-in: ${reason}`);
+    }
+    const check = classifyAuthorizeResponse({
+        domain: opts.domain,
+        status: response.status,
+        location: response.headers.get("location"),
+        body: await response.text(),
+    });
+    if (check.ok === false) {
+        failWith(check.message);
+    }
+}
+async function exchangeAuthorizationCode(opts) {
+    const config = getOAuthConfig();
+    const response = await postToAuth0({
+        path: "/oauth/token",
+        body: new URLSearchParams({
+            grant_type: "authorization_code",
+            client_id: config.clientId,
+            code: opts.code,
+            redirect_uri: opts.redirectUri,
+            code_verifier: opts.codeVerifier,
+        }),
+    });
+    if (response.ok === false) {
+        const errorBody = await readErrorBody(response);
+        failWith(`Failed to exchange the AgentID sign-in code (HTTP ${String(response.status)}): ${describeError(errorBody)}`, { extra: { oauthError: errorBody } });
+    }
+    return parseTokenResponse(await response.json());
+}
+function listenForCallback(expectedState) {
+    return new Promise((resolve, reject) => {
+        let settle;
+        let fail;
+        let settled = false;
+        const done = new Promise((resolveDone, rejectDone) => {
+            settle = resolveDone;
+            fail = rejectDone;
+        });
+        // The wait can reject while Auth0 is still being checked, before the
+        // caller awaits `done`. A handler here keeps that from surfacing as an
+        // unhandled rejection; awaiting `done` still throws.
+        void done.catch(() => undefined);
+        const finish = (search) => {
+            if (settled === true || settle === undefined) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timeout);
+            settle(search);
+        };
+        const giveUp = (error) => {
+            if (settled === true || fail === undefined) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timeout);
+            fail(error);
+        };
+        const server = createServer((req, res) => {
+            handleCallbackRequest(req, res, expectedState, finish);
+        });
+        const timeout = setTimeout(() => {
+            giveUp(new Error("AgentID sign-in timed out before the browser returned. The AgentID page expires after 5 minutes."));
+            server.close();
+        }, SIGN_IN_TIMEOUT_MS);
+        server.on("error", (error) => {
+            clearTimeout(timeout);
+            if (error.code === "EADDRINUSE") {
+                reject(new Error(`${AGENTID_CALLBACK_URL} is already in use. Free that port and run the command again.`));
+                return;
+            }
+            reject(error);
+        });
+        server.listen(AGENTID_CALLBACK_PORT, "127.0.0.1", () => {
+            const address = server.address();
+            if (address === null || typeof address === "string") {
+                reject(new Error("Could not bind a localhost port for AgentID sign-in."));
+                return;
+            }
+            resolve({
+                port: address.port,
+                done,
+                close: () => {
+                    clearTimeout(timeout);
+                    server.close();
+                },
+            });
+        });
+    });
+}
+function handleCallbackRequest(req, res, expectedState, finish) {
+    const requestUrl = req.url;
+    if (requestUrl === undefined) {
+        res.writeHead(400);
+        res.end();
+        return;
+    }
+    const url = new URL(requestUrl, "http://127.0.0.1");
+    if (url.pathname !== CALLBACK_PATH) {
+        res.writeHead(404);
+        res.end();
+        return;
+    }
+    const method = req.method === undefined ? "" : req.method;
+    if (isSignInCallback(method, url.search, expectedState) === false) {
+        res.writeHead(method === "GET" ? 404 : 405);
+        res.end();
+        return;
+    }
+    res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+    res.end("<!doctype html><title>Cargo</title><p>Sign-in finished. You can close this window and return to the terminal.</p>");
+    finish(url.search);
+}
+function htmlError(body) {
+    const match = body.match(/class="error-message">([\s\S]*?)<\/p>/);
+    if (match === null || match[1] === undefined) {
+        return undefined;
+    }
+    return match[1]
+        .replace(/<[^>]+>/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}

package/build/commands/auth/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/auth/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,OAAO,EAAU,MAAM,WAAW,CAAC;AAGjD,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAExC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AA2BxD,MAAM,MAAM,aAAa,GAAG;IAC1B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,MAAM,GAAG,GAChB,IAAI,CAsIN;AA2GD,MAAM,MAAM,cAAc,GAAG;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpE;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,WAAW,EAAE,WAAW,GAAG,SAAS,EACpC,IAAI,EAAE,aAAa,GAClB,cAAc,CAchB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/auth/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,OAAO,EAAU,MAAM,WAAW,CAAC;AAGjD,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAExC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AA6BxD,MAAM,MAAM,aAAa,GAAG;IAC1B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,MAAM,GAAG,GAChB,IAAI,CAwJN;AAqHD,MAAM,MAAM,cAAc,GAAG;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpE;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,WAAW,EAAE,WAAW,GAAG,SAAS,EACpC,IAAI,EAAE,aAAa,GAClB,cAAc,CAchB"}

package/build/commands/auth/index.js

@@ -6,6 +6,7 @@ import { clearCredentials, CredentialsNotClearedError, getCredentialsPath, loadC
 import { parseBooleanOption } from "../../utils/booleanOption.js";
 import { ExitCodes, failWith, handleApiCall, info, outputJson, success, } from "../runHandler.js";
 import { clearStartState } from "../start/state.js";
+import { runAgentIdLogin } from "./agentId.js";
 import { runEmailLogin } from "./email.js";
 import { selectLoginChannel } from "./loginChannel.js";
 import { runOAuthDeviceFlow } from "./oauth.js";
@@ -13,10 +14,11 @@ import { DEFAULT_BASE_URL, establishSession, resolveBaseUrl, } from "./session.j
 export function registerAuthCommands(program, getApi) {
     const login = program
         .command("login")
-        .description("Sign in to Cargo with an emailed code (--email), via browser (--oauth), or with an existing API token (--token)")
+        .description("Sign in to Cargo with an emailed code (--email), via browser (--oauth), with AgentID (--agentid), or with an existing API token (--token)")
         .option("--email <email>", "Sign in with a code emailed to this address; creates the account on first use")
         .option("--code <code>", 'Verification code from the email, or "-" to read it from stdin; omit to have one sent (--email only)')
         .option("--oauth [true|false]", "Sign in via browser using the OAuth 2.0 Device Authorization Flow", parseBooleanOption)
+        .option("--agentid [true|false]", "Sign in as an agent through the AgentID connection; prints an Auth0 URL and waits for it to redirect back to this machine", parseBooleanOption)
         .option("--token <token>", "Existing Cargo API token")
         .option("--workspace-name <name>", "Workspace to use, created if no workspace of that name exists (skips the workspace prompt)")
         .option("--workspace-uuid <uuid>", "Workspace UUID to sign in for (skips the workspace prompt)")
@@ -27,6 +29,7 @@ Examples:
   $ cargo-ai login --email you@company.com --code 123456 --workspace-name "Acme GTM"
   $ cargo-ai login --oauth
   $ cargo-ai login --oauth --workspace-uuid 550e8400-e29b-41d4-a716-446655440000
+  $ cargo-ai login --agentid
   $ cargo-ai login --token sk_live_abc123 --base-url https://api.custom.io
 
 --email and --oauth both create the account if it does not exist yet, so there
@@ -40,7 +43,14 @@ Signing in with an address that already has an account resolves to its existing
 workspace rather than creating one, and --workspace-name reuses a workspace of
 that name when one exists, so this is safe to re-run.
 
---email and --oauth save the signed-in session to
+--agentid signs an agent in as itself. The command prints an Auth0 URL with
+the AgentID connection and waits on http://127.0.0.1 for the redirect. Open
+that URL once; a second visit starts a different sign-in. It does not open the Cargo app. When
+AgentID shows an auth token, approve it with "agentmail inboxes authorize".
+The cargo-ai Auth0 application must allow http://127.0.0.1:52701/callback and have
+the AgentID connection enabled.
+
+--email, --oauth and --agentid save the signed-in session to
 ~/.config/cargo-ai/credentials.json and renew it automatically, so you stay
 signed in without a token being created for each machine. CARGO_CONFIG_DIR
 (or XDG_CONFIG_HOME) moves that file; where the home directory is not writable
@@ -66,6 +76,11 @@ Environment variables (CARGO_API_TOKEN, CARGO_WORKSPACE_UUID, CARGO_BASE_URL) ta
                 hint: "opens a browser; no code to copy",
                 flag: "--oauth",
             },
+            {
+                label: "AgentID",
+                hint: "an agent signs in as itself; approve the token AgentID shows",
+                flag: "--agentid",
+            },
             {
                 label: "Emailed code",
                 hint: "no browser needed; signs you up on first use",
@@ -88,7 +103,7 @@ Environment variables (CARGO_API_TOKEN, CARGO_WORKSPACE_UUID, CARGO_BASE_URL) ta
         // for; --keep-token stays the documented spelling for existing scripts.
         .addOption(new Option("--keep-session").hideHelp())
         .addHelpText("after", `
-A session from "cargo-ai login --email" or "--oauth" is revoked at the identity
+A session from "cargo-ai login --email", "--oauth" or "--agentid" is revoked at the identity
 provider, so signing out is final. Tokens you supplied yourself with --token are
 only forgotten locally, since they may be in use elsewhere.
 
@@ -136,7 +151,7 @@ async function runLogin(opts) {
         });
         return;
     }
-    const tokens = await runOAuthDeviceFlow();
+    const tokens = await tokensForChannel(selection.channel);
     const workspace = await establishSession({
         tokens,
         baseUrlOverride: opts.baseUrl,
@@ -154,6 +169,12 @@ async function runLogin(opts) {
         tokenType: "session",
     });
 }
+async function tokensForChannel(channel) {
+    if (channel === "agentid") {
+        return await runAgentIdLogin();
+    }
+    return await runOAuthDeviceFlow();
+}
 async function runLogout(opts) {
     const credentials = loadCredentials();
     const plan = planRevocation(credentials, opts);

package/build/commands/auth/loginChannel.d.ts

@@ -2,11 +2,14 @@ import type { EmailLoginOptions } from "./email.js";
 export type LoginOptions = EmailLoginOptions & {
     token?: string;
     oauth?: boolean;
+    agentid?: boolean;
 };
 export type LoginChannelSelection = {
     channel: "email";
 } | {
     channel: "oauth";
+} | {
+    channel: "agentid";
 } | {
     channel: "token";
     token: string;

package/build/commands/auth/loginChannel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loginChannel.d.ts","sourceRoot":"","sources":["../../../src/commands/auth/loginChannel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpD,MAAM,MAAM,YAAY,GAAG,iBAAiB,GAAG;IAC7C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAC7B;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,GACpB;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,GACpB;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACnC;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEtB;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,YAAY,GAAG,qBAAqB,CAmD5E"}
+{"version":3,"file":"loginChannel.d.ts","sourceRoot":"","sources":["../../../src/commands/auth/loginChannel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpD,MAAM,MAAM,YAAY,GAAG,iBAAiB,GAAG;IAC7C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAC7B;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,GACpB;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,GACpB;IAAE,OAAO,EAAE,SAAS,CAAA;CAAE,GACtB;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACnC;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEtB;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,YAAY,GAAG,qBAAqB,CA6D5E"}

package/build/commands/auth/loginChannel.js

@@ -5,16 +5,24 @@
 export function selectLoginChannel(opts) {
     const wantsEmail = opts.email !== undefined;
     const wantsOAuth = opts.oauth === true;
+    const wantsAgentId = opts.agentid === true;
     const wantsToken = opts.token !== undefined;
-    const selectedCount = [wantsEmail, wantsOAuth, wantsToken].filter((selected) => {
+    const selectedCount = [
+        wantsEmail,
+        wantsOAuth,
+        wantsAgentId,
+        wantsToken,
+    ].filter((selected) => {
         return selected === true;
     }).length;
     if (selectedCount > 1) {
-        return { error: "Pass only one of --email, --oauth or --token." };
+        return {
+            error: "Pass only one of --email, --oauth, --agentid or --token.",
+        };
     }
     if (selectedCount === 0) {
         return {
-            error: "Must pass --email <email> (emailed code), --oauth (browser sign-in) or --token <token> (existing API token).",
+            error: "Must pass --email <email> (emailed code), --oauth (browser sign-in), --agentid (AgentID) or --token <token> (existing API token).",
         };
     }
     if (opts.code !== undefined && wantsEmail === false) {
@@ -35,6 +43,9 @@ export function selectLoginChannel(opts) {
     if (opts.email !== undefined) {
         return { channel: "email" };
     }
+    if (opts.agentid === true) {
+        return { channel: "agentid" };
+    }
     if (opts.token !== undefined) {
         return { channel: "token", token: opts.token };
     }

package/build/index.js

@@ -62,6 +62,7 @@ Agent skills:
 Authentication:
   Emailed code:       cargo-ai login --email you@company.com  (no browser; signs you up on first use)
   Browser sign-in:    cargo-ai login --oauth
+  AgentID:            cargo-ai login --agentid
   With API token:     cargo-ai login --token <your-token>
   Use env variables:  CARGO_API_TOKEN, CARGO_WORKSPACE_UUID, CARGO_BASE_URL
   Check status:       cargo-ai whoami

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@cargo-ai/cli",
-  "version": "1.0.113",
+  "version": "1.0.115",
+  "mcpName": "io.github.getcargohq/cargo",
   "private": false,
   "license": "UNLICENSED",
   "homepage": "https://getcargo.ai",
@@ -73,7 +74,7 @@
   "dependencies": {
     "@ai-sdk/harness": "^1.0.144",
     "@ai-sdk/harness-claude-code": "^1.0.148",
-    "@cargo-ai/api": "^1.0.94",
+    "@cargo-ai/api": "^1.0.95",
     "@cargo-ai/app-sdk": "^1.0.11",
     "@cargo-ai/cdk": "^1.0.111",
     "@cargo-ai/types": "^1.0.96",