@cargo-ai/cli 1.0.72 → 1.0.73

package/build/commands/start/index.js

@@ -0,0 +1,431 @@
+// `cargo-ai start` — and what a bare `cargo-ai` opens when nobody is signed in
+// yet.
+//
+// Open a coding agent, run the guided demo, scaffold a CDK project, explore in
+// the palette, or nothing. Each is a value of `--continue`, so the whole flow
+// runs headless. `onboard` survives as an alias for anything already written
+// down.
+//
+// Three steps and no more: sign in, land in a workspace, choose where to carry
+// on. Everything past that belongs to whatever you chose — `cdk init` asks its
+// own questions about a project, a coding agent asks its own about the work.
+// The flow writes nothing to disk except its own state.
+//
+// Every question is also a flag, so the whole thing runs headless for an agent
+// or a docs snippet, and every step leaves a valid machine behind: cancel after
+// signing in and you are signed in.
+import { spawnSync } from "node:child_process";
+import { askText, availableCodingAgents, cdkProjectRoot, COMPANY_CONTEXT_PATH, hasCompanyContext, installedCookbooks, isInteractive, launchBriefed, requireAnswer, selectOne, skillsInstalledFor, } from "@cargo-ai/cdk/cli";
+import { AGENT_SKILLS_NEXT_STEP } from "../../agentSkills.js";
+import { isSignedIn } from "../../setupIssues.js";
+import { parseBooleanOption } from "../../utils/booleanOption.js";
+import { signInWithEmail } from "../auth/email.js";
+import { runOAuthDeviceFlow } from "../auth/oauth.js";
+import { establishSession } from "../auth/session.js";
+import { ExitCodes, failWith, handleApiCall, info, success, } from "../runHandler.js";
+import { buildBrief, buildDemoBrief, CDK_SKILL, DEMO_SKILL, EXPLORE_PATH, formatStartNextSteps, parseDestination, ROUTER_SKILL, } from "./brief.js";
+import { saveStartState } from "./state.js";
+const OAUTH = "oauth";
+const EMAIL = "email";
+/**
+ * Where the agent is about to be opened. Three cases, all decided locally —
+ * this runs before every handoff, including from the palette, so it must not
+ * touch the network.
+ *
+ * Exported for tests; `go` is the only production caller.
+ */
+export function resolveProjectContext(cwd) {
+    const root = cdkProjectRoot(cwd);
+    if (root === undefined) {
+        return { kind: "none" };
+    }
+    const companyContextPath = hasCompanyContext(root) === true ? COMPANY_CONTEXT_PATH : undefined;
+    const cookbooks = installedCookbooks(root);
+    if (cookbooks.length > 0) {
+        return { kind: "cookbook", root, companyContextPath, cookbooks };
+    }
+    return { kind: "cdk", root, companyContextPath };
+}
+export function registerStartCommand(program, getApi, deps) {
+    program
+        .command("start")
+        .alias("onboard")
+        .description("Open a coding agent, run the guided demo, or set up a project — signing you in first if needed")
+        .option("--email <email>", "Sign in with a code emailed to this address")
+        .option("--code <code>", "The emailed code, to finish a sign-in this command already started (`-` reads it from stdin)")
+        .option("--oauth [value]", "Sign in via browser", parseBooleanOption)
+        .option("--workspace-name <name>", "Workspace to use, created if it does not exist")
+        .option("--workspace-uuid <uuid>", "Workspace to use")
+        .option("--continue <where>", 'Where to continue: a coding agent ("claude", "cursor", "codex", "gemini"), "code" for a CDK project, "cli" for the palette, "demo" for the guided tour, or "none"')
+        .option("--directory <path>", "Directory to scaffold into, for `--continue code`. Required when there is nobody to ask; supplying it also skips the project wizard, the way `cdk init <directory>` does")
+        .option("--icp <description>", "Who you sell to, used to brief the guided demo")
+        .option("--base-url <url>", "Cargo API base URL")
+        .addHelpText("after", `
+This is what a bare \`cargo-ai\` opens for someone who has never signed in, and
+what to run any time after that to open an agent, take the tour, or start a
+project. Signed in already? The sign-in and workspace steps are skipped.
+
+Every question has a flag, so the whole flow runs unattended:
+  $ cargo-ai start --email you@company.com --workspace-name "Acme GTM" --continue claude
+
+Emailed sign-in takes two runs where there is no terminal to type the code
+into. The first sends the code and prints the second, which carries the same
+flags so the destination is not lost:
+  $ cargo-ai start --email you@company.com --continue claude --code 123456
+
+Already have an API token? \`cargo-ai login --token <token>\` is the whole setup.`)
+        .action(async (opts) => {
+        await runStart(getApi, deps, opts);
+    });
+}
+export async function runStart(getApi, deps, opts) {
+    // Checked before anything happens: a mistyped `--continue` is a usage
+    // error, and finding it out after a browser sign-in is a poor way to learn.
+    const supplied = opts.continue === undefined ? undefined : requireDestination(opts.continue);
+    // Same reasoning, one step further. Scaffolding headless needs a directory,
+    // and `cdk init` cannot ask for one — so without this the run signs in,
+    // saves its state, and *then* dies on a usage error from a child
+    // process, having done everything except the thing it was asked to do.
+    if (supplied !== undefined &&
+        supplied.kind === "code" &&
+        opts.directory === undefined &&
+        isInteractive() === false) {
+        requireAnswer({
+            needs: "scaffolding a project needs a directory to scaffold into",
+            retryCommand: "cargo-ai start --continue code --directory my-workspace",
+        });
+    }
+    info("");
+    info("Cargo — GTM infrastructure your agents can run on.");
+    info("");
+    const workspace = isSignedIn() === true ? await currentWorkspace(getApi) : await signIn(opts);
+    success(`Workspace: ${workspace.name}`);
+    const facts = {
+        workspace,
+        // Decides whether the briefs and the next-steps block tell the reader to
+        // go and install the skills. Shared with `ensureSkillsInstalled` so the
+        // two cannot disagree about a repo that carries its own copy.
+        skillsInstalled: skillsInstalledFor(process.cwd()),
+    };
+    const destination = supplied !== undefined ? supplied : await askDestination();
+    saveStartState({
+        version: 1,
+        completedAt: new Date().toISOString(),
+        workspaceUuid: workspace.uuid,
+        continued: destination.kind === "agent" ? destination.agent.bin : destination.kind,
+    });
+    await go(destination, facts, deps, opts);
+}
+/** Runs the chosen destination. */
+async function go(destination, facts, deps, opts) {
+    // A handoff may install the skills on its way past. When one then fails to
+    // launch, the block at the bottom of this function is what the user is left
+    // with, and reading the facts it came in with told them to install skills
+    // that had just been installed.
+    let known = facts;
+    if (destination.kind === "agent") {
+        // Offered before the agent starts, not mentioned in its brief afterwards:
+        // an agent that has to install its own instructions spends its first turn
+        // on setup, and often just guesses at the CLI instead.
+        const cwd = process.cwd();
+        // Resolved once and used twice: the context decides which skill the launch
+        // loads, and what the brief tells the agent to do once it is open.
+        const project = resolveProjectContext(cwd);
+        const skill = agentSkill(project);
+        const launch = await launchBriefed({
+            agent: destination.agent,
+            cwd,
+            skill,
+            brief: (skillsInstalled) => buildBrief({ ...facts, skillsInstalled }, skill, project),
+        });
+        known = { ...facts, skillsInstalled: launch.skillsInstalled };
+        if (launch.launched === true) {
+            return;
+        }
+    }
+    if (destination.kind === "demo") {
+        const demo = await runDemo(facts, opts);
+        known = demo.facts;
+        if (demo.launched === true) {
+            return;
+        }
+    }
+    if (destination.kind === "code") {
+        scaffoldProject(deps, opts);
+        return;
+    }
+    if (destination.kind === "cli") {
+        await deps.openPalette(EXPLORE_PATH);
+        return;
+    }
+    info("");
+    info(formatStartNextSteps(known));
+    if (known.skillsInstalled === false) {
+        info("");
+        info(AGENT_SKILLS_NEXT_STEP);
+    }
+}
+/**
+ * The skill to load for a general agent handoff: `cargo-cdk` when inside a
+ * CDK project (the user is building infra as code), `cargo` (the router)
+ * everywhere else.
+ */
+function agentSkill(project) {
+    return project.kind === "none" ? ROUTER_SKILL : CDK_SKILL;
+}
+/**
+ * Hand the whole project question to `cdk init`, which owns it: where the
+ * project goes, what it starts from, and the company questions worth asking
+ * once there is a repo to write the answers into.
+ *
+ * Returns only when a project was created. Anything else exits, because
+ * `start --continue code` is a scripted path, and reporting success over a
+ * project that does not exist is the one outcome nothing downstream can
+ * recover from.
+ */
+function scaffoldProject(deps, opts) {
+    // `init` asks for a directory only when it can; headless it needs one on the
+    // command line, which `--directory` is here to forward.
+    const scaffold = spawnSync(process.execPath, [
+        deps.binPath,
+        "cdk",
+        "init",
+        ...(opts.directory === undefined ? [] : [opts.directory]),
+    ], { stdio: "inherit" });
+    if (scaffold.error !== undefined) {
+        failWith(`Could not run \`cdk init\`: ${scaffold.error.message}`);
+    }
+    // The child has already said what went wrong on this terminal, so this
+    // carries its code rather than adding a second message. A null status means
+    // a signal killed it, which must not read as a scaffolded project either.
+    if (scaffold.status !== 0) {
+        process.exit(scaffold.status === null ? ExitCodes.GenericError : scaffold.status);
+    }
+}
+/**
+ * The guided demo: find companies matching an ICP, then the people at them.
+ * It runs inside a coding agent rather than as a scripted CLI sequence —
+ * sourcing is a conversation about who you sell to, and the agent can price
+ * each step and stop when the answer is good enough.
+ *
+ * Returns whether one started, and the facts as they now stand: this may
+ * have installed the skills, which the caller's fallback has to know about.
+ */
+async function runDemo(facts, opts) {
+    const agents = availableCodingAgents();
+    const icp = opts.icp !== undefined && opts.icp.length > 0
+        ? opts.icp
+        : isInteractive() === false
+            ? undefined
+            : blankToUndefined(await askText({
+                message: "Who are you trying to reach? (Enter to skip)",
+                placeholder: "heads of growth at Series B SaaS in Europe",
+                defaultValue: "",
+                // Enter already skips it; Escape must not instead throw away a
+                // sign-in and the destination that came with it.
+                skippable: true,
+            }));
+    const agent = agents[0];
+    if (agent === undefined) {
+        info("");
+        info("The demo runs inside a coding agent, and none is installed on this machine.");
+        info("Install one (Claude Code, Cursor, Codex, Gemini CLI) and run:");
+        info("  cargo-ai start --continue demo");
+        return { launched: false, facts };
+    }
+    const launch = await launchBriefed({
+        agent,
+        cwd: process.cwd(),
+        skill: DEMO_SKILL,
+        brief: (skillsInstalled) => buildDemoBrief({ ...facts, skillsInstalled }, icp),
+    });
+    return {
+        launched: launch.launched,
+        facts: { ...facts, skillsInstalled: launch.skillsInstalled },
+    };
+}
+async function currentWorkspace(getApi) {
+    const api = getApi();
+    const { workspace } = await handleApiCall(() => api.workspaceManagement.workspace.getCurrent());
+    return { uuid: workspace.uuid, name: workspace.name };
+}
+async function signIn(opts) {
+    const channel = await chooseChannel(opts);
+    return channel === EMAIL
+        ? await signInByEmail(opts)
+        : await signInByBrowser(opts);
+}
+/**
+ * Sign in with an emailed code, which takes two runs where there is no
+ * terminal to type the code into: the first sends it and prints the command
+ * that finishes the job — see `resumeCommand` for why that is `start` again
+ * rather than `login`.
+ */
+async function signInByEmail(opts) {
+    const email = opts.email !== undefined && opts.email.length > 0
+        ? opts.email
+        : await askText({
+            message: "Your work email",
+            placeholder: "you@company.com",
+            defaultValue: "",
+            validate: (raw) => raw !== undefined && raw.includes("@") === true
+                ? undefined
+                : "That does not look like an email address.",
+        });
+    const result = await signInWithEmail({
+        email,
+        code: opts.code,
+        workspaceName: opts.workspaceName,
+        workspaceUuid: opts.workspaceUuid,
+        baseUrl: opts.baseUrl,
+        resumeCommand: resumeCommand(email, opts),
+    });
+    if (result.outcome === "codeSent") {
+        // The code is already sent, so this is a pause rather than a failure.
+        info(`Re-run with the code to finish: ${result.next}`);
+        process.exit(ExitCodes.Success);
+    }
+    success(`Signed in as ${result.email}.`);
+    return result.workspace;
+}
+async function signInByBrowser(opts) {
+    const workspace = await establishSession({
+        tokens: await runOAuthDeviceFlow(),
+        baseUrlOverride: opts.baseUrl,
+        workspaceUuid: opts.workspaceUuid,
+        workspaceName: opts.workspaceName,
+    });
+    success("Signed in.");
+    return workspace;
+}
+/**
+ * The command that finishes what this run started, for a machine with no
+ * terminal to type the emailed code into.
+ *
+ * It has to be `start` rather than `login`: `login --code` signs the user in
+ * and stops, so the destination this run was headed for is lost and re-running
+ * `start --email` issues a second code instead of spending the first. Every
+ * flag that decided where this was going is carried over.
+ *
+ * Exported for tests; `signIn` is the only production caller.
+ */
+export function resumeCommand(email, opts) {
+    const carried = [
+        ["--email", email],
+        ["--continue", opts.continue],
+        ["--directory", opts.directory],
+        ["--workspace-name", opts.workspaceName],
+        ["--workspace-uuid", opts.workspaceUuid],
+        ["--icp", opts.icp],
+        ["--base-url", opts.baseUrl],
+    ];
+    const flags = carried
+        .filter((entry) => entry[1] !== undefined)
+        .map(([flag, value]) => `${flag} ${shellArgument(value)}`);
+    // `<code>` is a placeholder for the reader to replace, not a value, so it is
+    // not quoted — quoting would read as something to type literally.
+    return `cargo-ai start ${flags.join(" ")} --code <code>`;
+}
+/**
+ * `value` as one shell argument.
+ *
+ * This line is printed to be run — copied by a person or relayed by an agent —
+ * and every value in it came off a command line the caller controls. Wrapping
+ * in double quotes, as this used to, means a value carrying a quote ends the
+ * argument early and the rest is read as more command. Single quotes have
+ * exactly one escape to handle and no interpolation inside them.
+ *
+ * Left bare when there is nothing to quote, so the common case still reads as
+ * something you would type.
+ */
+function shellArgument(value) {
+    // Not `-foo`: bare, the next `cargo-ai` would read it as a flag rather than
+    // as this flag's value, and the line is printed to be run.
+    if (/^[\w.@:/=-]+$/.test(value) === true && value.startsWith("-") === false) {
+        return value;
+    }
+    return `'${value.split("'").join(`'\\''`)}'`;
+}
+async function chooseChannel(opts) {
+    if (opts.email !== undefined && opts.email.length > 0) {
+        return EMAIL;
+    }
+    if (opts.oauth === true) {
+        return OAUTH;
+    }
+    if (isInteractive() === false) {
+        requireAnswer({
+            needs: "`cargo-ai start` needs to know how to sign you in",
+            retryCommand: "cargo-ai start --email you@company.com",
+        });
+    }
+    return await selectOne({
+        message: "How do you want to sign in?",
+        recommended: OAUTH,
+        choices: [
+            {
+                value: OAUTH,
+                label: "Browser sign-in",
+                hint: "opens a browser; nothing to copy",
+            },
+            {
+                value: EMAIL,
+                label: "Emailed code",
+                hint: "no browser; signs you up on first use",
+            },
+        ],
+    });
+}
+/** `--continue <where>`, or a usage error naming what it accepts. */
+function requireDestination(value) {
+    const parsed = parseDestination(value, availableCodingAgents());
+    if (parsed === undefined) {
+        failWith(`Cannot continue in "${value}". Expected a coding agent installed on this machine, "code", "cli", "demo" or "none".`, { code: ExitCodes.InvalidUsage });
+    }
+    return parsed;
+}
+async function askDestination() {
+    const agents = availableCodingAgents();
+    if (isInteractive() === false) {
+        return { kind: "none" };
+    }
+    const chosen = await selectOne({
+        message: "What do you want to do?",
+        recommended: agents[0] === undefined ? "demo" : agents[0].bin,
+        choices: [
+            ...agents.map((agent) => ({
+                value: agent.bin,
+                label: `Open ${agent.label}`,
+                hint: "briefed on this workspace",
+            })),
+            {
+                value: "cli",
+                label: "Explore in the CLI",
+                hint: "the action catalog, in the palette",
+            },
+            {
+                value: "code",
+                label: "Set it up as code",
+                hint: "scaffold a CDK project with cargo-ai cdk init",
+            },
+            {
+                value: "demo",
+                label: "Show me a guided demo",
+                hint: "find companies, then the people, matching your ICP",
+            },
+            { value: "none", label: "Nothing for now", hint: "print the next steps" },
+        ],
+    });
+    const parsed = parseDestination(chosen, agents);
+    if (parsed === undefined) {
+        return { kind: "none" };
+    }
+    return parsed;
+}
+/** Clack returns the empty fallback for a skipped question; absent is undefined. */
+function blankToUndefined(answer) {
+    if (answer.trim() === "") {
+        return undefined;
+    }
+    return answer.trim();
+}

package/build/commands/start/state.d.ts

@@ -0,0 +1,50 @@
+export type StartState = {
+    version: 1;
+    completedAt: string;
+    workspaceUuid: string;
+    /** Where the person chose to continue: an agent bin, or "code"/"cli"/"demo"/"none". */
+    continued?: string;
+};
+export declare function getStartStatePath(): string;
+export declare function loadStartState(): StartState | undefined;
+/**
+ * `value` as state, or undefined when it is not.
+ *
+ * Checked rather than cast, because the file is on a disk people edit and the
+ * cast promised a shape nothing verified. Unknown `version` reads as absent so
+ * a future format degrades to "never ran" — the entrance opens once more,
+ * which is the harmless direction.
+ *
+ * Exported for tests; `loadStartState` is the only production caller.
+ */
+export declare function asStartState(value: unknown): StartState | undefined;
+/**
+ * Best-effort: a machine that cannot write its config directory — a sandbox, a
+ * read-only home — has still just been through the flow, and failing the
+ * command at the end of a successful one would be the worst possible moment to
+ * complain.
+ */
+export declare function saveStartState(state: StartState): boolean;
+/**
+ * Forget that this machine has been through the flow, so the next bare
+ * `cargo-ai` runs it again. Signing out is the one unambiguous "start me over"
+ * this CLI has — someone who does it and then types `cargo-ai` is asking for
+ * the entrance, not for a palette of commands that all exit 3.
+ */
+export declare function clearStartState(): boolean;
+/**
+ * Whether a bare `cargo-ai` should run `start` rather than open the palette.
+ *
+ * Deliberately not "are you signed in" alone: the entrance greets a person
+ * once. After that, and for anything that is not a person at a terminal, bare
+ * `cargo-ai` keeps doing exactly what it did before.
+ *
+ * Exported for tests; `index.ts` is the only production caller.
+ */
+export declare function shouldRunStart(input: {
+    signedIn: boolean;
+    interactive: boolean;
+    /** Whether the flow has already run on this machine. */
+    ranBefore: boolean;
+}): boolean;
+//# sourceMappingURL=state.d.ts.map

package/build/commands/start/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../src/commands/start/state.ts"],"names":[],"mappings":"AAqBA,MAAM,MAAM,UAAU,GAAG;IACvB,OAAO,EAAE,CAAC,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,uFAAuF;IACvF,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,wBAAgB,iBAAiB,IAAI,MAAM,CAE1C;AAED,wBAAgB,cAAc,IAAI,UAAU,GAAG,SAAS,CAYvD;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,GAAG,SAAS,CA0BnE;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAUzD;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,IAAI,OAAO,CAOzC;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE;IACpC,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,OAAO,CAAC;IACrB,wDAAwD;IACxD,SAAS,EAAE,OAAO,CAAC;CACpB,GAAG,OAAO,CAMV"}

package/build/commands/start/state.js

@@ -0,0 +1,101 @@
+// What `start` remembers between runs.
+//
+// The file exists to answer one question — "has this machine been through the
+// flow?" — because the alternative signal, "is there a credential?", is wrong
+// in both directions: someone who signs out has still seen the entrance, and
+// someone who has only ever run `cargo-ai login --token` in CI has not.
+//
+// It sits beside the credentials rather than in the repo: this is a fact about
+// a person and their machine, not about a project.
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync, } from "node:fs";
+import { join } from "node:path";
+import { getConfigDir } from "@cargo-ai/cdk/cli";
+export function getStartStatePath() {
+    return join(getConfigDir(), "start.json");
+}
+export function loadStartState() {
+    const path = getStartStatePath();
+    if (existsSync(path) === false) {
+        return undefined;
+    }
+    try {
+        return asStartState(JSON.parse(readFileSync(path, "utf-8")));
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * `value` as state, or undefined when it is not.
+ *
+ * Checked rather than cast, because the file is on a disk people edit and the
+ * cast promised a shape nothing verified. Unknown `version` reads as absent so
+ * a future format degrades to "never ran" — the entrance opens once more,
+ * which is the harmless direction.
+ *
+ * Exported for tests; `loadStartState` is the only production caller.
+ */
+export function asStartState(value) {
+    if (value === null || typeof value !== "object") {
+        return undefined;
+    }
+    const { version, completedAt, workspaceUuid, continued } = value;
+    if (version !== 1 ||
+        typeof completedAt !== "string" ||
+        typeof workspaceUuid !== "string") {
+        return undefined;
+    }
+    return {
+        version: 1,
+        completedAt,
+        workspaceUuid,
+        continued: typeof continued === "string" ? continued : undefined,
+    };
+}
+/**
+ * Best-effort: a machine that cannot write its config directory — a sandbox, a
+ * read-only home — has still just been through the flow, and failing the
+ * command at the end of a successful one would be the worst possible moment to
+ * complain.
+ */
+export function saveStartState(state) {
+    try {
+        mkdirSync(getConfigDir(), { recursive: true });
+        writeFileSync(getStartStatePath(), `${JSON.stringify(state, null, 2)}\n`, {
+            mode: 0o600,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Forget that this machine has been through the flow, so the next bare
+ * `cargo-ai` runs it again. Signing out is the one unambiguous "start me over"
+ * this CLI has — someone who does it and then types `cargo-ai` is asking for
+ * the entrance, not for a palette of commands that all exit 3.
+ */
+export function clearStartState() {
+    try {
+        rmSync(getStartStatePath(), { force: true });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Whether a bare `cargo-ai` should run `start` rather than open the palette.
+ *
+ * Deliberately not "are you signed in" alone: the entrance greets a person
+ * once. After that, and for anything that is not a person at a terminal, bare
+ * `cargo-ai` keeps doing exactly what it did before.
+ *
+ * Exported for tests; `index.ts` is the only production caller.
+ */
+export function shouldRunStart(input) {
+    return (input.interactive === true &&
+        input.signedIn === false &&
+        input.ranBefore === false);
+}

package/build/config.d.ts

@@ -7,6 +7,7 @@ export type Config = {
      */
     getAccessToken: AccessTokenProvider | undefined;
     baseUrl: string;
+    appUrl: string;
     workspaceUuid: string | undefined;
     source: ConfigSource;
 };

package/build/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAO7D,MAAM,MAAM,YAAY,GAAG,aAAa,GAAG,kBAAkB,GAAG,MAAM,CAAC;AAEvE,MAAM,MAAM,MAAM,GAAG;IACnB;;;OAGG;IACH,cAAc,EAAE,mBAAmB,GAAG,SAAS,CAAC;IAChD,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,MAAM,EAAE,YAAY,CAAC;CACtB,CAAC;AAEF,wBAAgB,SAAS,IAAI,MAAM,CA0BlC;AAED;;;;;;;;;GASG;AACH,wBAAgB,iCAAiC,CAAC,IAAI,EAAE;IACtD,qBAAqB,EAAE,OAAO,CAAC;IAC/B,WAAW,EAAE,YAAY,CAAC;IAC1B,wBAAwB,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7C,sBAAsB,EAAE,MAAM,GAAG,SAAS,CAAC;CAC5C,GAAG,MAAM,GAAG,SAAS,CA0BrB"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAO7D,MAAM,MAAM,YAAY,GAAG,aAAa,GAAG,kBAAkB,GAAG,MAAM,CAAC;AAEvE,MAAM,MAAM,MAAM,GAAG;IACnB;;;OAGG;IACH,cAAc,EAAE,mBAAmB,GAAG,SAAS,CAAC;IAChD,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,MAAM,EAAE,YAAY,CAAC;CACtB,CAAC;AAEF,wBAAgB,SAAS,IAAI,MAAM,CA2BlC;AAED;;;;;;;;;GASG;AACH,wBAAgB,iCAAiC,CAAC,IAAI,EAAE;IACtD,qBAAqB,EAAE,OAAO,CAAC;IAC/B,WAAW,EAAE,YAAY,CAAC;IAC1B,wBAAwB,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7C,sBAAsB,EAAE,MAAM,GAAG,SAAS,CAAC;CAC5C,GAAG,MAAM,GAAG,SAAS,CA0BrB"}

package/build/config.js

@@ -19,6 +19,7 @@ export function getConfig() {
     return {
         getAccessToken: resolved.getAccessToken,
         baseUrl: resolved.baseUrl,
+        appUrl: resolved.appUrl,
         workspaceUuid: resolved.workspaceUuid,
         source: resolved.tokenSource,
     };