@microsoft/managed-apps-cli 0.19.0 → 0.21.0

package/dist/Utils/GitErrorClassifier.js

@@ -1,120 +0,0 @@
-/*!
- * Copyright (C) Microsoft Corporation. All rights reserved.
- */
-import { AuthenticationError, NetworkError } from '../Errors/CliError.js';
-// A single "authentication failed" message is too vague to act on. Git's stderr
-// carries enough signal to separate the three auth failure modes the GRS flow
-// hits, each with a different fix. Order matters: the credential-rejected (403)
-// and prompt-unavailable rules are checked before the generic catch-all because
-// their stderr often also contains the word "authentication".
-const AUTH_RULES = [
-    // A credential was sent but the remote rejected it. For the GRS flow this is
-    // an authorization problem, not a bad password: either the signed-in account
-    // is wrong/under-permissioned, or GCM silently returned a cached credential
-    // for a different identity than the current `ms auth` profile.
-    {
-        patterns: [/403 forbidden/i, /returned error: 403/i, /access denied/i],
-        bucket: 'auth-403',
-        build: (action) => `Git reached the remote but access was denied while ${action} (HTTP 403). This usually ` +
-            `means one of:\n` +
-            `  - the signed-in account is in the wrong tenant, or lacks permission to this app's repo; or\n` +
-            `  - Git Credential Manager returned a cached credential for a different account than your ` +
-            `current 'ms auth' sign-in (a stale or mismatched credential).\n` +
-            `Confirm 'ms auth status' shows the account and tenant for this environment. If it doesn't ` +
-            `match, clear the cached git credential for the host ('git credential-manager erase', or ` +
-            `remove it from your OS credential store) so Git re-prompts, then re-run.`,
-    },
-    // No usable credential and git cannot prompt for one: either Git Credential
-    // Manager isn't configured, or the session is non-interactive (no TTY /
-    // GIT_TERMINAL_PROMPT=0) so the browser sign-in never opens.
-    {
-        patterns: [
-            /terminal prompts disabled/i,
-            /could not read username/i,
-            /could not read password/i,
-        ],
-        bucket: 'auth-prompt-unavailable',
-        build: (action) => `Git could not obtain a credential while ${action}: there is no cached credential and the ` +
-            `session can't prompt for one. Make sure Git Credential Manager is installed, then re-run ` +
-            `in an interactive terminal so the browser sign-in can complete.`,
-    },
-    // A credential was tried but is invalid or expired — the recoverable case is a
-    // fresh browser sign-in (or clearing a stale cached credential).
-    {
-        patterns: [/authentication failed/i, /invalid username or password/i],
-        bucket: 'auth-invalid-credential',
-        build: (action) => `Git authentication failed while ${action}: the credential was missing, invalid, or expired. ` +
-            `When the browser opens, sign in with the account for this environment's tenant; if a stale ` +
-            `credential is cached, clear it in Git Credential Manager and re-run.`,
-    },
-];
-// Network patterns are intentionally conservative: only stderr we are confident
-// maps to connectivity is classified. Anything ambiguous (e.g. "repository not
-// found", "permission denied to a path", TLS/cert errors) is left unrecognized
-// so the original error bubbles up untouched rather than being mislabeled.
-const NETWORK_PATTERNS = [
-    /could not resolve host/i,
-    /could not resolve proxy/i,
-    /failed to connect/i,
-    /connection timed out/i,
-    /connection refused/i,
-    /network is unreachable/i,
-    /temporary failure in name resolution/i,
-];
-/**
- * Redacts credential-bearing userinfo from any URL in git's output before that
- * output is embedded verbatim in a user-facing error message. The classified
- * message can reach the `--json` envelope, which CI pipelines and agent
- * orchestrators capture — so a credential must never ride along.
- *
- * The GRS flow's GCM browser-OAuth keeps tokens out of stderr, so this is
- * defense-in-depth: a no-op in the normal case, but a guard against a
- * PAT-in-URL helper or a GCM fallback that prints a credential-bearing remote
- * like `https://oauth2:TOKEN@host/` or `git://TOKEN@host/`. We match any
- * `scheme://` authority (http, https, ssh, git, …) and strip the entire
- * userinfo (covering both `user:secret@` and bare `token@` forms) up to the
- * `@`, without crossing a `/` or whitespace so only the authority is touched.
- */
-function redactUrlCredentials(text) {
-    return text.replace(/(\b[a-z][a-z0-9+.-]*:\/\/)[^/\s@]+@/gi, '$1[REDACTED]@');
-}
-/**
- * Maps raw git failure output to a CLI-facing {@link AppError} subclass so a
- * native (platform-managed) git operation that fails on auth or network reports
- * the right exit code and a cause-specific, actionable message instead of an
- * opaque `fatal: Authentication failed`.
- *
- * Auth failures are split into distinct buckets (credential rejected / no
- * promptable credential / invalid-or-expired credential) so the user gets the
- * fix that matches their situation rather than one generic "sign in again".
- * Each returned error also carries a stable `errorData.classifierBucket` (plus
- * the `action`) for telemetry without re-parsing the message text.
- *
- * The returned message embeds the original git output verbatim (callers and
- * tests substring-match on git's own wording). Returns `null` for any output
- * that doesn't clearly match a known category, signalling the caller to
- * re-throw the original error unchanged.
- *
- * Note: this is deliberately scoped to the platform-managed (GRS) git flow,
- * whose credentials come from Git Credential Manager's browser OAuth — NOT the
- * external GitHub-repo flow (which has its own `git auth refresh` recovery).
- */
-export function classifyLocalGitError(rawOutput, context) {
-    const detail = redactUrlCredentials(rawOutput.trimEnd());
-    if (!detail)
-        return null;
-    for (const rule of AUTH_RULES) {
-        if (rule.patterns.some((p) => p.test(detail))) {
-            return new AuthenticationError(`${rule.build(context.action)}\n\nGit output:\n${detail}`, {
-                classifierBucket: rule.bucket,
-                action: context.action,
-            });
-        }
-    }
-    if (NETWORK_PATTERNS.some((p) => p.test(detail))) {
-        return new NetworkError(`Git could not reach the remote while ${context.action}. Check your network ` +
-            `connection (and proxy settings, if any) and try again.\n\nGit output:\n${detail}`, { classifierBucket: 'network', action: context.action });
-    }
-    return null;
-}
-//# sourceMappingURL=GitErrorClassifier.js.map

package/dist/Utils/GitErrorClassifier.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"GitErrorClassifier.js","sourceRoot":"","sources":["../../src/Utils/GitErrorClassifier.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAiCvE,gFAAgF;AAChF,8EAA8E;AAC9E,gFAAgF;AAChF,gFAAgF;AAChF,8DAA8D;AAC9D,MAAM,UAAU,GAAe;IAC7B,6EAA6E;IAC7E,6EAA6E;IAC7E,4EAA4E;IAC5E,+DAA+D;IAC/D;QACE,QAAQ,EAAE,CAAC,gBAAgB,EAAE,sBAAsB,EAAE,gBAAgB,CAAC;QACtE,MAAM,EAAE,UAAU;QAClB,KAAK,EAAE,CAAC,MAAM,EAAE,EAAE,CAChB,sDAAsD,MAAM,4BAA4B;YACxF,iBAAiB;YACjB,gGAAgG;YAChG,4FAA4F;YAC5F,iEAAiE;YACjE,4FAA4F;YAC5F,0FAA0F;YAC1F,0EAA0E;KAC7E;IACD,4EAA4E;IAC5E,wEAAwE;IACxE,6DAA6D;IAC7D;QACE,QAAQ,EAAE;YACR,4BAA4B;YAC5B,0BAA0B;YAC1B,0BAA0B;SAC3B;QACD,MAAM,EAAE,yBAAyB;QACjC,KAAK,EAAE,CAAC,MAAM,EAAE,EAAE,CAChB,2CAA2C,MAAM,0CAA0C;YAC3F,2FAA2F;YAC3F,iEAAiE;KACpE;IACD,+EAA+E;IAC/E,iEAAiE;IACjE;QACE,QAAQ,EAAE,CAAC,wBAAwB,EAAE,+BAA+B,CAAC;QACrE,MAAM,EAAE,yBAAyB;QACjC,KAAK,EAAE,CAAC,MAAM,EAAE,EAAE,CAChB,mCAAmC,MAAM,qDAAqD;YAC9F,6FAA6F;YAC7F,sEAAsE;KACzE;CACF,CAAC;AAEF,gFAAgF;AAChF,+EAA+E;AAC/E,+EAA+E;AAC/E,2EAA2E;AAC3E,MAAM,gBAAgB,GAAa;IACjC,yBAAyB;IACzB,0BAA0B;IAC1B,oBAAoB;IACpB,uBAAuB;IACvB,qBAAqB;IACrB,yBAAyB;IACzB,uCAAuC;CACxC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,SAAS,oBAAoB,CAAC,IAAY;IACxC,OAAO,IAAI,CAAC,OAAO,CAAC,uCAAuC,EAAE,eAAe,CAAC,CAAC;AAChF,CAAC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,qBAAqB,CACnC,SAAiB,EACjB,OAA2B;IAE3B,MAAM,MAAM,GAAG,oBAAoB,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC,CAAC;IACzD,IAAI,CAAC,MAAM;QAAE,OAAO,IAAI,CAAC;IAEzB,KAAK,MAAM,IAAI,IAAI,UAAU,EAAE,CAAC;QAC9B,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;YAC9C,OAAO,IAAI,mBAAmB,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,oBAAoB,MAAM,EAAE,EAAE;gBACxF,gBAAgB,EAAE,IAAI,CAAC,MAAM;gBAC7B,MAAM,EAAE,OAAO,CAAC,MAAM;aACvB,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAED,IAAI,gBAAgB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;QACjD,OAAO,IAAI,YAAY,CACrB,wCAAwC,OAAO,CAAC,MAAM,uBAAuB;YAC3E,0EAA0E,MAAM,EAAE,EACpF,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,CACxD,CAAC;IACJ,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/Utils/GitHubDcfFlow.d.ts

@@ -1,59 +0,0 @@
-/*!
- * Copyright (C) Microsoft Corporation. All rights reserved.
- */
-import type { GitHubDcfDisplay } from '@microsoft/managed-apps-actions';
-/**
- * Console implementation of {@link GitHubDcfDisplay}. Uses the standard CLI
- * print helpers: the user code lives in its own paragraph for visibility,
- * and the success message uses the soft "expires around" wording.
- */
-export declare const ConsoleGitHubDcfDisplay: GitHubDcfDisplay;
-/**
- * NDJSON implementation of {@link GitHubDcfDisplay} for `--json` mode.
- * Emits one line per call to stdout.
- *
- * Browser launching is intentionally a no-op in JSON mode — automated callers
- * are not expected to have a desktop session.
- */
-export declare class JsonGitHubDcfDisplay implements GitHubDcfDisplay {
-    showUserCode(info: {
-        sessionId: string;
-        userCode: string;
-        verificationUri: string;
-        expiresIn: number;
-        pollIntervalSeconds: number;
-    }): void;
-    showWaiting(): void;
-    showPollIteration(): void;
-    showComplete(info: {
-        githubLogin: string;
-        mappingExpiresAt: string;
-    }): void;
-    private _emit;
-}
-export interface OpenVerificationUriOptions {
-    /** When true, skip the launch entirely and return false. */
-    skip: boolean;
-}
-/**
- * Best-effort cross-platform launcher for the GitHub verification URI.
- *
- * Returns `false` (and does nothing) when:
- *   - `options.skip` is true (e.g. caller did not pass `--open-browser`)
- *   - stdin is not a TTY (piped / non-interactive)
- *   - `MS_NO_BROWSER=1` is set
- *   - `CI=true` is set
- *   - `uri` does not parse, or is not an `https:` URL (we refuse to hand
- *     `http:`, `file:`, `javascript:`, etc. to a platform launcher)
- *   - `process.platform` is not one of `win32` / `darwin` / `linux`
- *
- * Otherwise spawns the platform-appropriate launcher (`start` on Windows,
- * `open` on macOS, `xdg-open` elsewhere) using {@link spawn} with `shell:false`
- * so cmd metacharacters in the URL can't be interpreted. The launched child is
- * detached and `unref()`ed so we don't keep the CLI alive waiting on it. All
- * errors are swallowed and the function returns `false` — failure to launch a
- * browser must never abort the device-code flow because the user can always
- * copy the URL from stdout.
- */
-export declare function openVerificationUriBestEffort(uri: string, options: OpenVerificationUriOptions): boolean;
-//# sourceMappingURL=GitHubDcfFlow.d.ts.map

package/dist/Utils/GitHubDcfFlow.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"GitHubDcfFlow.d.ts","sourceRoot":"","sources":["../../src/Utils/GitHubDcfFlow.ts"],"names":[],"mappings":"AAAA;;GAEG;AAgBH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAKxE;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,EAAE,gBAsBrC,CAAC;AAEF;;;;;;GAMG;AACH,qBAAa,oBAAqB,YAAW,gBAAgB;IAC3D,YAAY,CAAC,IAAI,EAAE;QACjB,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,MAAM,CAAC;QACjB,eAAe,EAAE,MAAM,CAAC;QACxB,SAAS,EAAE,MAAM,CAAC;QAClB,mBAAmB,EAAE,MAAM,CAAC;KAC7B,GAAG,IAAI;IAWR,WAAW,IAAI,IAAI;IAKnB,iBAAiB,IAAI,IAAI;IAIzB,YAAY,CAAC,IAAI,EAAE;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,gBAAgB,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAU3E,OAAO,CAAC,KAAK;CAId;AAED,MAAM,WAAW,0BAA0B;IACzC,4DAA4D;IAC5D,IAAI,EAAE,OAAO,CAAC;CACf;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,6BAA6B,CAC3C,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAoCT"}

package/dist/Utils/GitHubDcfFlow.js

@@ -1,165 +0,0 @@
-/*!
- * Copyright (C) Microsoft Corporation. All rights reserved.
- */
-/**
- * Display implementations for the GitHub Device Code Flow, plus a best-effort
- * cross-platform browser launcher.
- *
- *   - {@link ConsoleGitHubDcfDisplay} — human-readable output for interactive
- *     terminals.
- *   - {@link JsonGitHubDcfDisplay} — NDJSON events for `--json` mode, matching
- *     the design's frozen event vocabulary.
- *   - {@link openVerificationUriBestEffort} — TTY/CI/env-gated launcher used
- *     by the console display.
- */
-import { spawn } from 'node:child_process';
-import { printInfo, printJsonLine } from './ConsoleOutput.js';
-import { getSystemEnvVar } from './EnvVars.js';
-/**
- * Console implementation of {@link GitHubDcfDisplay}. Uses the standard CLI
- * print helpers: the user code lives in its own paragraph for visibility,
- * and the success message uses the soft "expires around" wording.
- */
-export const ConsoleGitHubDcfDisplay = {
-    showUserCode({ userCode, verificationUri, expiresIn }) {
-        // sessionId and pollIntervalSeconds travel on the payload for the JSON
-        // display's NDJSON event but aren't surfaced in the human-readable output —
-        // the user doesn't need to see them and they'd just clutter the prompt.
-        printInfo('');
-        printInfo('First copy your one-time code:');
-        printInfo('');
-        printInfo(`      ${userCode}`);
-        printInfo('');
-        printInfo('Then visit this URL to sign in to GitHub:');
-        printInfo('');
-        printInfo(`      ${verificationUri}`);
-        printInfo('');
-        printInfo(`(Code expires in ${Math.round(expiresIn / 60)} minutes.)`);
-    },
-    showWaiting() {
-        printInfo('Waiting for authentication...');
-    },
-    openVerificationUri(uri) {
-        return openVerificationUriBestEffort(uri, { skip: false });
-    },
-};
-/**
- * NDJSON implementation of {@link GitHubDcfDisplay} for `--json` mode.
- * Emits one line per call to stdout.
- *
- * Browser launching is intentionally a no-op in JSON mode — automated callers
- * are not expected to have a desktop session.
- */
-export class JsonGitHubDcfDisplay {
-    showUserCode(info) {
-        this._emit({
-            phase: 'github-auth-initiated',
-            sessionId: info.sessionId,
-            userCode: info.userCode,
-            verificationUri: info.verificationUri,
-            expiresIn: info.expiresIn,
-            pollIntervalSeconds: info.pollIntervalSeconds,
-        });
-    }
-    showWaiting() {
-        // No-op in JSON mode: the first 'github-auth-pending' event is emitted by
-        // showPollIteration() so we don't duplicate it.
-    }
-    showPollIteration() {
-        this._emit({ phase: 'github-auth-pending' });
-    }
-    showComplete(info) {
-        this._emit({
-            phase: 'github-auth-complete',
-            githubLogin: info.githubLogin,
-            mappingExpiresAt: info.mappingExpiresAt,
-        });
-    }
-    // No openVerificationUri override — JSON mode never opens a browser.
-    _emit(event) {
-        // NDJSON: one JSON document per line, no pretty-printing.
-        printJsonLine(event);
-    }
-}
-/**
- * Best-effort cross-platform launcher for the GitHub verification URI.
- *
- * Returns `false` (and does nothing) when:
- *   - `options.skip` is true (e.g. caller did not pass `--open-browser`)
- *   - stdin is not a TTY (piped / non-interactive)
- *   - `MS_NO_BROWSER=1` is set
- *   - `CI=true` is set
- *   - `uri` does not parse, or is not an `https:` URL (we refuse to hand
- *     `http:`, `file:`, `javascript:`, etc. to a platform launcher)
- *   - `process.platform` is not one of `win32` / `darwin` / `linux`
- *
- * Otherwise spawns the platform-appropriate launcher (`start` on Windows,
- * `open` on macOS, `xdg-open` elsewhere) using {@link spawn} with `shell:false`
- * so cmd metacharacters in the URL can't be interpreted. The launched child is
- * detached and `unref()`ed so we don't keep the CLI alive waiting on it. All
- * errors are swallowed and the function returns `false` — failure to launch a
- * browser must never abort the device-code flow because the user can always
- * copy the URL from stdout.
- */
-export function openVerificationUriBestEffort(uri, options) {
-    if (options.skip)
-        return false;
-    if (process.stdin.isTTY === false)
-        return false;
-    if (getSystemEnvVar('MS_NO_BROWSER') === '1')
-        return false;
-    if (getSystemEnvVar('CI') === 'true')
-        return false;
-    // Refuse anything that isn't a parseable https:// URL. The verificationUri
-    // ultimately comes from a server response; treat it as untrusted input
-    // rather than blindly handing it to the OS shell.
-    let parsed;
-    try {
-        parsed = new URL(uri);
-    }
-    catch {
-        return false;
-    }
-    if (parsed.protocol !== 'https:')
-        return false;
-    try {
-        const command = buildLauncherSpawnArgs(uri, process.platform);
-        if (!command)
-            return false;
-        const child = spawn(command.file, command.args, {
-            shell: false,
-            detached: true,
-            stdio: 'ignore',
-        });
-        // Failure to spawn (e.g. xdg-open missing) emits async 'error'; swallow it
-        // so a missing launcher binary never crashes the CLI.
-        child.on('error', () => {
-            // Best-effort: ignore.
-        });
-        child.unref();
-        return true;
-    }
-    catch {
-        // Some hosts (e.g. extremely locked-down CI) may even block spawn; never throw.
-        return false;
-    }
-}
-function buildLauncherSpawnArgs(uri, platform) {
-    switch (platform) {
-        case 'win32':
-            // The empty "" is the window title argument that `start` consumes when its
-            // first quoted argument is the URL — without it `start` treats the URL as
-            // the window title and does nothing useful. With shell:false, the URL
-            // travels as its own argv element so `&calc.exe`-style metacharacters
-            // can't be reinterpreted by cmd.
-            return { file: 'cmd.exe', args: ['/c', 'start', '', uri] };
-        case 'darwin':
-            return { file: 'open', args: [uri] };
-        case 'linux':
-            return { file: 'xdg-open', args: [uri] };
-        default:
-            // freebsd, aix, sunos, openbsd, etc. — no agreed-upon launcher.
-            return undefined;
-    }
-}
-//# sourceMappingURL=GitHubDcfFlow.js.map

package/dist/Utils/GitHubDcfFlow.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"GitHubDcfFlow.js","sourceRoot":"","sources":["../../src/Utils/GitHubDcfFlow.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAI3C,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAE5C;;;;GAIG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAqB;IACvD,YAAY,CAAC,EAAE,QAAQ,EAAE,eAAe,EAAE,SAAS,EAAE;QACnD,uEAAuE;QACvE,4EAA4E;QAC5E,wEAAwE;QACxE,SAAS,CAAC,EAAE,CAAC,CAAC;QACd,SAAS,CAAC,gCAAgC,CAAC,CAAC;QAC5C,SAAS,CAAC,EAAE,CAAC,CAAC;QACd,SAAS,CAAC,SAAS,QAAQ,EAAE,CAAC,CAAC;QAC/B,SAAS,CAAC,EAAE,CAAC,CAAC;QACd,SAAS,CAAC,2CAA2C,CAAC,CAAC;QACvD,SAAS,CAAC,EAAE,CAAC,CAAC;QACd,SAAS,CAAC,SAAS,eAAe,EAAE,CAAC,CAAC;QACtC,SAAS,CAAC,EAAE,CAAC,CAAC;QACd,SAAS,CAAC,oBAAoB,IAAI,CAAC,KAAK,CAAC,SAAS,GAAG,EAAE,CAAC,YAAY,CAAC,CAAC;IACxE,CAAC;IACD,WAAW;QACT,SAAS,CAAC,+BAA+B,CAAC,CAAC;IAC7C,CAAC;IACD,mBAAmB,CAAC,GAAG;QACrB,OAAO,6BAA6B,CAAC,GAAG,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;IAC7D,CAAC;CACF,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,OAAO,oBAAoB;IAC/B,YAAY,CAAC,IAMZ;QACC,IAAI,CAAC,KAAK,CAAC;YACT,KAAK,EAAE,uBAAuB;YAC9B,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,eAAe,EAAE,IAAI,CAAC,eAAe;YACrC,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,mBAAmB,EAAE,IAAI,CAAC,mBAAmB;SAC9C,CAAC,CAAC;IACL,CAAC;IAED,WAAW;QACT,0EAA0E;QAC1E,gDAAgD;IAClD,CAAC;IAED,iBAAiB;QACf,IAAI,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,qBAAqB,EAAE,CAAC,CAAC;IAC/C,CAAC;IAED,YAAY,CAAC,IAAuD;QAClE,IAAI,CAAC,KAAK,CAAC;YACT,KAAK,EAAE,sBAAsB;YAC7B,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,gBAAgB,EAAE,IAAI,CAAC,gBAAgB;SACxC,CAAC,CAAC;IACL,CAAC;IAED,qEAAqE;IAE7D,KAAK,CAAC,KAA8B;QAC1C,0DAA0D;QAC1D,aAAa,CAAC,KAAK,CAAC,CAAC;IACvB,CAAC;CACF;AAOD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,6BAA6B,CAC3C,GAAW,EACX,OAAmC;IAEnC,IAAI,OAAO,CAAC,IAAI;QAAE,OAAO,KAAK,CAAC;IAC/B,IAAI,OAAO,CAAC,KAAK,CAAC,KAAK,KAAK,KAAK;QAAE,OAAO,KAAK,CAAC;IAChD,IAAI,eAAe,CAAC,eAAe,CAAC,KAAK,GAAG;QAAE,OAAO,KAAK,CAAC;IAC3D,IAAI,eAAe,CAAC,IAAI,CAAC,KAAK,MAAM;QAAE,OAAO,KAAK,CAAC;IAEnD,2EAA2E;IAC3E,uEAAuE;IACvE,kDAAkD;IAClD,IAAI,MAAW,CAAC;IAChB,IAAI,CAAC;QACH,MAAM,GAAG,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC;IACxB,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;IACD,IAAI,MAAM,CAAC,QAAQ,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IAE/C,IAAI,CAAC;QACH,MAAM,OAAO,GAAG,sBAAsB,CAAC,GAAG,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;QAC9D,IAAI,CAAC,OAAO;YAAE,OAAO,KAAK,CAAC;QAC3B,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,EAAE;YAC9C,KAAK,EAAE,KAAK;YACZ,QAAQ,EAAE,IAAI;YACd,KAAK,EAAE,QAAQ;SAChB,CAAC,CAAC;QACH,2EAA2E;QAC3E,sDAAsD;QACtD,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE;YACrB,uBAAuB;QACzB,CAAC,CAAC,CAAC;QACH,KAAK,CAAC,KAAK,EAAE,CAAC;QACd,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,MAAM,CAAC;QACP,gFAAgF;QAChF,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAOD,SAAS,sBAAsB,CAAC,GAAW,EAAE,QAAyB;IACpE,QAAQ,QAAQ,EAAE,CAAC;QACjB,KAAK,OAAO;YACV,2EAA2E;YAC3E,0EAA0E;YAC1E,sEAAsE;YACtE,sEAAsE;YACtE,iCAAiC;YACjC,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,GAAG,CAAC,EAAE,CAAC;QAC7D,KAAK,QAAQ;YACX,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;QACvC,KAAK,OAAO;YACV,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;QAC3C;YACE,gEAAgE;YAChE,OAAO,SAAS,CAAC;IACrB,CAAC;AACH,CAAC"}

package/dist/Utils/GitRunner.d.ts

@@ -1,107 +0,0 @@
-/*!
- * Copyright (C) Microsoft Corporation. All rights reserved.
- */
-import { type GitClassifyContext } from './GitErrorClassifier.js';
-/**
- * Options for {@link runGit}.
- */
-export interface RunGitOptions {
-    /** Working directory the git command runs in. Defaults to `process.cwd()`. */
-    cwd?: string;
-    /**
-     * Marks a remote-touching op (fetch / push / clone). For a network op that is
-     * neither classified nor a silent probe, stderr is *inherited* so git's live
-     * progress and any interactive credential prompts reach the user's terminal in
-     * real time instead of being buffered and only re-emitted after the process
-     * exits (these call sites own their own messaging and don't need the captured
-     * text).
-     *
-     * Setting `classify` *overrides* this live-streaming behavior: a classified
-     * network op keeps stderr piped so the failure output is available to
-     * {@link classifyLocalGitError} (the user sees no live progress — only the
-     * classified message once the op finishes). `allowFailure` probes likewise
-     * keep stderr piped so the caller can inspect {@link GitResult.stderr}.
-     */
-    network?: boolean;
-    /**
-     * When true, a non-zero exit (or a spawn failure such as `git` missing from
-     * PATH) returns a {@link GitResult} with `success: false` instead of
-     * throwing. Use for probes whose failure is an expected, recoverable signal
-     * (e.g. `rev-parse --verify origin/main` on an empty repo, or `remote add`
-     * when origin already exists).
-     */
-    allowFailure?: boolean;
-    /**
-     * Capture the command's stdout and return it on {@link GitResult.stdout}.
-     * Defaults to false (stdout is discarded) since most git mutations write
-     * nothing useful to stdout.
-     */
-    captureStdout?: boolean;
-    /**
-     * Re-emit captured stderr to the parent process's stderr so the user still
-     * sees git's own message. Defaults to true. Set false for silent probes
-     * where a non-zero exit is an expected control-flow signal, not an error to
-     * surface.
-     */
-    emitStderr?: boolean;
-    /**
-     * Opt-in error classification for the throwing path (ignored when
-     * `allowFailure` is true). When set and the command fails, the captured
-     * output is run through {@link classifyLocalGitError}; a recognized
-     * auth/network failure is re-thrown as a typed {@link AppError} (carrying the
-     * right exit code) whose message embeds git's original output. Unrecognized
-     * output falls through to the normal emit-and-rethrow of the original error.
-     *
-     * Scoped to the platform-managed (GRS) git flow — do NOT set it for the
-     * external GitHub-repo clone or the template clone, which own their own
-     * messaging and use different credentials.
-     */
-    classify?: GitClassifyContext;
-}
-/**
- * Structured outcome of a git invocation, modeled as a discriminated union on
- * `success` so the type system encodes the failure invariant: a failed op
- * always carries its caught {@link Error}, a successful one never does. `stderr`
- * is populated only on the failure path (and for `allowFailure` probes):
- * `execFileSync` exposes a command's stderr just on the thrown error, so a
- * *successful* piped op's stderr is not captured here (it's discarded). On
- * failure, the captured text is what enables downstream classification — e.g. a
- * failed network op's `fatal: Authentication failed…` is available to the
- * caller instead of vanishing into an inherited terminal stream.
- */
-export type GitResult = {
-    success: true;
-    /** Always 0 on the success path. */
-    status: 0;
-    stdout: string;
-    stderr: string;
-} | {
-    success: false;
-    /** Process exit code, or null when the process could not be spawned. */
-    status: number | null;
-    stdout: string;
-    stderr: string;
-    /** The caught error (non-zero exit or spawn failure); always present. */
-    error: Error;
-};
-/**
- * Single chokepoint for every `git` invocation in the CLI.
- *
- * Centralizing git here gives one stdio policy (stdin ignored so a child can
- * never block waiting for input; stderr piped so a *failure's* output is
- * captured rather than lost to an inherited stream) and one place to hang
- * pre/post checks on. Because `execFileSync` only surfaces stderr via the
- * thrown error, capture applies to the failure path: on failure the captured
- * stderr is re-emitted by default so users still see git's own message, and is
- * also returned (on `allowFailure`) or attached to the thrown error
- * (`error.stderr`) for classification. A *successful* piped op's stderr is not
- * captured (it is discarded). The one exception to piping is an un-classified,
- * non-probe {@link RunGitOptions.network} op, whose stderr is inherited so live
- * progress and credential prompts stream straight through on success too.
- *
- * On failure with `allowFailure: false` (the default), the *original* error is
- * re-thrown so existing message-based handling keeps working — the caught error
- * now additionally carries a populated `stderr` because we pipe it.
- */
-export declare function runGit(args: string[], options?: RunGitOptions): GitResult;
-//# sourceMappingURL=GitRunner.d.ts.map

package/dist/Utils/GitRunner.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"GitRunner.d.ts","sourceRoot":"","sources":["../../src/Utils/GitRunner.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,EAAyB,KAAK,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAEtF;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,8EAA8E;IAC9E,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;;;OAIG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;;OAKG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,EAAE,kBAAkB,CAAC;CAC/B;AAED;;;;;;;;;;GAUG;AACH,MAAM,MAAM,SAAS,GACjB;IACE,OAAO,EAAE,IAAI,CAAC;IACd,oCAAoC;IACpC,MAAM,EAAE,CAAC,CAAC;IACV,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,GACD;IACE,OAAO,EAAE,KAAK,CAAC;IACf,wEAAwE;IACxE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,yEAAyE;IACzE,KAAK,EAAE,KAAK,CAAC;CACd,CAAC;AAkBN;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,OAAO,GAAE,aAAkB,GAAG,SAAS,CAgE7E"}

package/dist/Utils/GitRunner.js

@@ -1,89 +0,0 @@
-/*!
- * Copyright (C) Microsoft Corporation. All rights reserved.
- */
-import { execFileSync } from 'child_process';
-import { classifyLocalGitError } from './GitErrorClassifier.js';
-function toStr(value) {
-    if (value == null)
-        return '';
-    return Buffer.isBuffer(value) ? value.toString() : value;
-}
-/**
- * Explicit stdout/stderr capture ceiling for every git invocation. Node's
- * `execFileSync` defaults to a 1 MB `maxBuffer`; exceeding it throws `ENOBUFS`
- * (treated by callers as a generic failure). `ls-tree -r HEAD` on a large repo,
- * or verbose clone/fetch progress, can blow past 1 MB — and an `allowFailure`
- * probe would silently misread that `ENOBUFS` as its expected control-flow
- * signal (e.g. "repo is empty"). A generous ceiling avoids those spurious
- * failures while still guarding against runaway memory.
- */
-const GIT_MAX_BUFFER_BYTES = 64 * 1024 * 1024;
-/**
- * Single chokepoint for every `git` invocation in the CLI.
- *
- * Centralizing git here gives one stdio policy (stdin ignored so a child can
- * never block waiting for input; stderr piped so a *failure's* output is
- * captured rather than lost to an inherited stream) and one place to hang
- * pre/post checks on. Because `execFileSync` only surfaces stderr via the
- * thrown error, capture applies to the failure path: on failure the captured
- * stderr is re-emitted by default so users still see git's own message, and is
- * also returned (on `allowFailure`) or attached to the thrown error
- * (`error.stderr`) for classification. A *successful* piped op's stderr is not
- * captured (it is discarded). The one exception to piping is an un-classified,
- * non-probe {@link RunGitOptions.network} op, whose stderr is inherited so live
- * progress and credential prompts stream straight through on success too.
- *
- * On failure with `allowFailure: false` (the default), the *original* error is
- * re-thrown so existing message-based handling keeps working — the caught error
- * now additionally carries a populated `stderr` because we pipe it.
- */
-export function runGit(args, options = {}) {
-    const { cwd, allowFailure = false, captureStdout = false, emitStderr = true, classify, network = false, } = options;
-    // A network op that is neither classified nor a silent probe streams git's
-    // stderr live (progress + interactive credential prompts) instead of
-    // buffering it; every other case pipes stderr so it can be captured for
-    // classification or returned to the caller.
-    const inheritStderr = network && !classify && !allowFailure;
-    try {
-        const stdout = execFileSync('git', args, {
-            cwd,
-            stdio: ['ignore', captureStdout ? 'pipe' : 'ignore', inheritStderr ? 'inherit' : 'pipe'],
-            maxBuffer: GIT_MAX_BUFFER_BYTES,
-        });
-        return {
-            success: true,
-            status: 0,
-            stdout: captureStdout ? toStr(stdout) : '',
-            stderr: '',
-        };
-    }
-    catch (err) {
-        const e = err;
-        const stderr = toStr(e.stderr);
-        // Classification runs on the throwing path only, and BEFORE we re-emit
-        // stderr: a recognized failure is re-thrown as a typed AppError whose
-        // message already embeds git's output, so emitting stderr here too would
-        // double-print it (the top-level catch prints the thrown message).
-        if (classify && !allowFailure) {
-            const text = stderr || toStr(e.stdout) || (err instanceof Error ? err.message : String(err));
-            const classified = classifyLocalGitError(text, classify);
-            if (classified) {
-                throw classified;
-            }
-        }
-        if (emitStderr && stderr) {
-            process.stderr.write(stderr);
-        }
-        if (!allowFailure) {
-            throw err;
-        }
-        return {
-            success: false,
-            status: typeof e.status === 'number' ? e.status : null,
-            stdout: toStr(e.stdout),
-            stderr,
-            error: err instanceof Error ? err : new Error(String(err)),
-        };
-    }
-}
-//# sourceMappingURL=GitRunner.js.map

package/dist/Utils/GitRunner.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"GitRunner.js","sourceRoot":"","sources":["../../src/Utils/GitRunner.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAE7C,OAAO,EAAE,qBAAqB,EAA2B,MAAM,sBAAsB,CAAC;AAwFtF,SAAS,KAAK,CAAC,KAAyC;IACtD,IAAI,KAAK,IAAI,IAAI;QAAE,OAAO,EAAE,CAAC;IAC7B,OAAO,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;AAC3D,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,oBAAoB,GAAG,EAAE,GAAG,IAAI,GAAG,IAAI,CAAC;AAE9C;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,MAAM,CAAC,IAAc,EAAE,UAAyB,EAAE;IAChE,MAAM,EACJ,GAAG,EACH,YAAY,GAAG,KAAK,EACpB,aAAa,GAAG,KAAK,EACrB,UAAU,GAAG,IAAI,EACjB,QAAQ,EACR,OAAO,GAAG,KAAK,GAChB,GAAG,OAAO,CAAC;IAEZ,2EAA2E;IAC3E,qEAAqE;IACrE,wEAAwE;IACxE,4CAA4C;IAC5C,MAAM,aAAa,GAAG,OAAO,IAAI,CAAC,QAAQ,IAAI,CAAC,YAAY,CAAC;IAE5D,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,YAAY,CAAC,KAAK,EAAE,IAAI,EAAE;YACvC,GAAG;YACH,KAAK,EAAE,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC;YACxF,SAAS,EAAE,oBAAoB;SAChC,CAAC,CAAC;QACH,OAAO;YACL,OAAO,EAAE,IAAI;YACb,MAAM,EAAE,CAAC;YACT,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE;YAC1C,MAAM,EAAE,EAAE;SACX,CAAC;IACJ,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,CAAC,GAAG,GAIT,CAAC;QACF,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;QAE/B,uEAAuE;QACvE,sEAAsE;QACtE,yEAAyE;QACzE,mEAAmE;QACnE,IAAI,QAAQ,IAAI,CAAC,YAAY,EAAE,CAAC;YAC9B,MAAM,IAAI,GAAG,MAAM,IAAI,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;YAC7F,MAAM,UAAU,GAAG,qBAAqB,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;YACzD,IAAI,UAAU,EAAE,CAAC;gBACf,MAAM,UAAU,CAAC;YACnB,CAAC;QACH,CAAC;QAED,IAAI,UAAU,IAAI,MAAM,EAAE,CAAC;YACzB,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QAC/B,CAAC;QAED,IAAI,CAAC,YAAY,EAAE,CAAC;YAClB,MAAM,GAAG,CAAC;QACZ,CAAC;QAED,OAAO;YACL,OAAO,EAAE,KAAK;YACd,MAAM,EAAE,OAAO,CAAC,CAAC,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI;YACtD,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC;YACvB,MAAM;YACN,KAAK,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;SAC3D,CAAC;IACJ,CAAC;AACH,CAAC"}

package/dist/Utils/GitUtils.d.ts

@@ -1,43 +0,0 @@
-/*!
- * Copyright (C) Microsoft Corporation. All rights reserved.
- */
-export interface GitDefaults {
-    branch: string;
-    commitSha: string;
-    detached: boolean;
-}
-export interface InitializeLocalGitRepoResult {
-    success: boolean;
-    error?: string;
-}
-/**
- * Reads the current branch and commit SHA from the working directory's git repo.
- * Returns null when git is unavailable or the directory is not a git repo.
- * `detached` is true when HEAD is not on a branch; in that case `branch` is the
- * literal string 'HEAD' and callers should not treat it as a branch name.
- */
-export declare function resolveGitDefaults(): GitDefaults | null;
-/**
- * Reads the current git remote origin URL from the working directory's git repo.
- * Returns null when git is unavailable or the directory is not a git repo
- */
-export declare function getCurrentGitRemoteUrl(): string | undefined;
-/**
- * Initializes a local git repository in the current working directory and
- * optionally configures the origin remote in the supplied working directory.
- * Returns true when `git init` succeeds, false when git is unavailable or the
- * command fails for any reason (e.g. permissions). Callers should treat false as
- * a soft failure — the app was already created; git can be initialized manually.
- */
-export declare function initializeLocalGitRepo(remoteUrl?: string, cwd?: string): InitializeLocalGitRepoResult;
-export interface GitDeployStatus {
-    hasUncommittedChanges: boolean | null;
-    isMainAheadOfOrigin: boolean | null;
-}
-/**
- * Reports the two local states that can make a git-backed deploy differ from origin/main:
- * uncommitted file changes and commits on local main that are not on origin/main. Each result is
- * null when git cannot determine that state, allowing callers to handle the checks independently.
- */
-export declare function getGitDeployStatus(): GitDeployStatus;
-//# sourceMappingURL=GitUtils.d.ts.map

package/dist/Utils/GitUtils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"GitUtils.d.ts","sourceRoot":"","sources":["../../src/Utils/GitUtils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,4BAA4B;IAC3C,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,IAAI,WAAW,GAAG,IAAI,CAkBvD;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,GAAG,SAAS,CAQ3D;AA0BD;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,CAAC,EAAE,MAAM,EAClB,GAAG,SAAgB,GAClB,4BAA4B,CA0B9B;AAED,MAAM,WAAW,eAAe;IAC9B,qBAAqB,EAAE,OAAO,GAAG,IAAI,CAAC;IACtC,mBAAmB,EAAE,OAAO,GAAG,IAAI,CAAC;CACrC;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,IAAI,eAAe,CAkBpD"}