feat: app dashboards capability + plugin template chrome upgrade

packages/build-tools/tsconfig.json

@@ -16,6 +16,7 @@
     "useDefineForClassFields": true,
     "module": "ESNext",
     "moduleResolution": "Bundler",
+    "ignoreDeprecations": "6.0",
     "skipLibCheck": true,
     "resolveJsonModule": true,
     "isolatedModules": true,

packages/cli/src/index.ts

@@ -24,6 +24,7 @@ import {
     useProfile,
     type CreateProfileOptions,
 } from './profiles/commands.js';
+import { configureGitAuth, serveGitCredential } from './profiles/git.js';
 import { AVAILABLE_REGIONS, DEFAULT_REGION, getConfigFile } from './profiles/index.js';
 import { listProjects, useProject } from './projects/index.js';
 import runInteraction from './run/index.js';
@@ -58,7 +59,7 @@ const authRoot = program.command("auth")
 
 authRoot.command("login [profile]")
     .description("Authenticate a profile, creating it when it does not exist")
-    .option("-t, --target <env>", "The target environment for a new profile. Possible values are: local, dev-main, dev-preview, preview, prod or a custom URL.")
+    .option("-t, --target <env>", "The target environment for a new profile. Possible values are: local, preview, prod, or a custom URL.")
     .option("-r, --region <region>", `Deployment region for a new profile: ${AVAILABLE_REGIONS.join(', ')}. Defaults to ${DEFAULT_REGION}. Only applies to preview and prod targets.`)
     .option("-p, --project <project>", "Authenticate for the given project ID")
     .option("-a, --account <account>", "The account ID to use when creating a profile")
@@ -89,6 +90,21 @@ authRoot.command("refresh")
     .option("-p, --project <project>", "Refresh the current profile token for the given project ID")
     .action((options: { project?: string }) => updateCurrentProfile(undefined, undefined, options))
 
+const authGit = authRoot.command("git")
+    .description("Configure Git to authenticate to Vertesia app repositories with the active profile token.")
+    .option("-p, --profile <profile>", "Profile to use for Git credentials. Defaults to the active profile.")
+    .option("--url <url>", "Git server base URL, for example https://git.dev1.vertesia.io.")
+    .option("--no-alias", "Do not configure the vertesia:<app>.git short alias.")
+    .action((options: { profile?: string; url?: string; alias?: boolean }) => configureGitAuth(options));
+
+authGit.command("credential [action]")
+    .description("Git credential helper entrypoint. Called by git; users should run `vertesia auth git` instead.")
+    .action(function (this: import("commander").Command, action: string | undefined) {
+        // --profile is declared on the parent `auth git`, so read via globals.
+        const profile = this.optsWithGlobals().profile as string | undefined;
+        return serveGitCredential(action, { profile });
+    });
+
 program.command("envs [envId]")
     .description("List the environments you have access to")
     .action((envId: string | undefined, options: Record<string, any>) => {
@@ -169,7 +185,7 @@ profilesRoot.command('use [name]')
     });
 profilesRoot.command('add [name]')
     .alias('create')
-    .option("-t, --target <env>", "The target environment for the profile. Possible values are: local, dev-main, dev-preview, preview, prod or a custom URL.")
+    .option("-t, --target <env>", "The target environment for the profile. Possible values are: local, preview, prod, or a custom URL.")
     .option("-r, --region <region>", `Deployment region: ${AVAILABLE_REGIONS.join(', ')}. Defaults to ${DEFAULT_REGION}. Only applies to preview and prod targets.`)
     .option("-k, --apikey <key>", "The API key or auth token to use for the profile")
     .option("-p, --project <project>", "The project ID to use for the profile")

packages/cli/src/profiles/commands.ts

@@ -281,8 +281,8 @@ export async function createProfile(name?: string, options: CreateProfileOptions
         });
     }
     if (!options.target) {
-        // only show dev environments in dev mode
-        const choices = config.isDevMode ? ['local', 'dev-main', 'dev-preview', 'preview', 'prod', 'custom'] : ['preview', 'prod'];
+        // Branch/dev deployments are custom URLs so profile config is explicit.
+        const choices = config.isDevMode ? ['local', 'preview', 'prod', 'custom'] : ['preview', 'prod', 'custom'];
         questions.push({
             type: 'select',
             name: 'target',

packages/cli/src/profiles/git.ts

@@ -0,0 +1,212 @@
+import { execFileSync } from 'node:child_process';
+import process from 'node:process';
+import { ensureProfileAccessToken } from './auth.js';
+import { config, type Profile } from './index.js';
+
+interface GitAuthOptions {
+    profile?: string;
+    url?: string;
+    alias?: boolean;
+}
+
+interface GitCredentialInput {
+    protocol?: string;
+    host?: string;
+    path?: string;
+}
+
+export async function configureGitAuth(options: GitAuthOptions = {}) {
+    const profile = getRequestedProfile(options.profile);
+    const gitBaseUrl = normalizeGitBaseUrl(options.url || gitServerUrlForProfile(profile));
+    const helper = `!vertesia auth git credential --profile ${shellQuote(profile.name)}`;
+
+    gitConfig('--global', `credential.${gitBaseUrl}.helper`, helper);
+    gitConfig('--global', `credential.${gitBaseUrl}.useHttpPath`, 'true');
+
+    if (options.alias !== false) {
+        removeKnownVertesiaAliases();
+        gitConfig('--global', `url.${gitBaseUrl}/.insteadOf`, 'vertesia:');
+    }
+
+    console.log(`Configured Git authentication for ${gitBaseUrl}`);
+    console.log(`Clone with: git clone ${gitBaseUrl}/<app-slug>.git`);
+    if (options.alias !== false) {
+        console.log('Short alias: git clone vertesia:<app-slug>.git');
+    }
+}
+
+export async function serveGitCredential(action: string | undefined, options: Pick<GitAuthOptions, 'profile'> = {}) {
+    if (!action || action === 'get') {
+        const envToken = process.env.VERTESIA_AUTH_TOKEN || process.env.VERTESIA_TOKEN;
+        if (envToken) {
+            writeCredential(envToken);
+            return;
+        }
+
+        const input = await readCredentialInput();
+        const profile = pickProfileForCredential(input, options.profile);
+        if (!profile) {
+            if (options.profile) {
+                throw new Error(
+                    `Vertesia profile '${options.profile}' was not found. Run \`vertesia auth git\` from an active profile.`,
+                );
+            }
+            throw new Error(
+                `No Vertesia profile matches git host ${input.host || '<unknown>'}. Run \`vertesia auth git\`.`,
+            );
+        }
+
+        const token = await ensureProfileAccessToken(profile);
+        if (!token) {
+            throw new Error(`Profile ${profile.name} has no usable auth token. Run \`vertesia auth refresh\`.`);
+        }
+        writeCredential(token);
+        return;
+    }
+
+    // Git may call helpers with store/erase. Tokens are managed by Vertesia CLI
+    // profile auth, so there is nothing useful to persist from Git.
+}
+
+function getRequestedProfile(profileName?: string): Profile {
+    if (profileName) {
+        const profile = config.getProfile(profileName);
+        if (!profile) throw new Error(`Profile ${profileName} not found.`);
+        return profile;
+    }
+    if (!config.current) {
+        throw new Error(
+            'No Vertesia profile is selected. Run `vertesia auth login` or `vertesia profiles use <name>`.',
+        );
+    }
+    return config.current;
+}
+
+function pickProfileForCredential(input: GitCredentialInput, profileName?: string): Profile | undefined {
+    if (profileName) {
+        return config.getProfile(profileName);
+    }
+    const host = input.host?.toLowerCase();
+    if (!host) return config.current;
+    if (config.current && gitHostForProfile(config.current) === host) {
+        return config.current;
+    }
+    return config.profiles.find(profile => gitHostForProfile(profile) === host);
+}
+
+function gitHostForProfile(profile: Profile): string | undefined {
+    try {
+        return new URL(gitServerUrlForProfile(profile)).hostname.toLowerCase();
+    } catch {
+        return undefined;
+    }
+}
+
+function gitServerUrlForProfile(profile: Profile): string {
+    const override = process.env.VERTESIA_GIT_SERVER_URL
+        || process.env.APP_GIT_SERVER_URL
+        || process.env.APPGEN_GIT_SERVER_URL;
+    if (override) return normalizeGitBaseUrl(override);
+
+    const sourceUrl = profile.studio_server_url || profile.zeno_server_url || profile.config_url;
+    try {
+        const url = new URL(sourceUrl);
+        const host = url.hostname.toLowerCase();
+        if (host === 'localhost' || host === '127.0.0.1' || host.endsWith('.local')) {
+            return 'https://git.dev1.vertesia.io';
+        }
+        if (host === 'api.vertesia.io' || host === 'api-preview.vertesia.io') {
+            return 'https://git.vertesia.io';
+        }
+        if (host.startsWith('api-preview.')) {
+            return `https://${host.replace(/^api-preview\./, 'git.')}`;
+        }
+        if (host.startsWith('api.')) {
+            return `https://${host.replace(/^api\./, 'git.')}`;
+        }
+
+        const parts = host.split('.');
+        const apiIndex = parts.indexOf('api');
+        const region = apiIndex >= 0 ? parts[apiIndex + 1] : undefined;
+        if (region && parts[apiIndex + 2] === 'vertesia') {
+            return `https://git.${region}.vertesia.io`;
+        }
+    } catch {
+        // Fall through to profile region/default below.
+    }
+
+    if (profile.region) return `https://git.${profile.region}.vertesia.io`;
+    return 'https://git.dev1.vertesia.io';
+}
+
+function normalizeGitBaseUrl(value: string): string {
+    const normalized = value.replace(/\/+$/, '');
+    if (!normalized.startsWith('http://') && !normalized.startsWith('https://')) {
+        throw new Error(`Git server URL must be an http(s) URL: ${value}`);
+    }
+    return normalized;
+}
+
+function gitConfig(...args: string[]) {
+    execFileSync('git', ['config', ...args], { stdio: 'pipe' });
+}
+
+function removeKnownVertesiaAliases() {
+    let raw: string;
+    try {
+        raw = execFileSync('git', ['config', '--global', '--get-regexp', '^url\\..*\\.insteadOf$'], {
+            stdio: ['ignore', 'pipe', 'ignore'],
+            encoding: 'utf8',
+        });
+    } catch {
+        // No matching keys, or no global config — nothing to clean up.
+        return;
+    }
+    for (const line of raw.split('\n')) {
+        const space = line.indexOf(' ');
+        if (space < 0) continue;
+        const key = line.slice(0, space);
+        const value = line.slice(space + 1);
+        if (value !== 'vertesia:') continue;
+        try {
+            execFileSync('git', ['config', '--global', '--unset-all', key, '^vertesia:$'], { stdio: 'ignore' });
+        } catch {
+            // Best-effort; ignore if the key disappears between read and unset.
+        }
+    }
+}
+
+function shellQuote(value: string): string {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
+async function readCredentialInput(): Promise<GitCredentialInput> {
+    const text = await readStdin();
+    const input: Record<string, string> = {};
+    for (const line of text.split(/\r?\n/)) {
+        if (!line) break;
+        const separator = line.indexOf('=');
+        if (separator < 0) continue;
+        input[line.slice(0, separator)] = line.slice(separator + 1);
+    }
+    return input;
+}
+
+function readStdin(): Promise<string> {
+    return new Promise((resolve, reject) => {
+        let text = '';
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', chunk => {
+            text += chunk;
+        });
+        process.stdin.on('end', () => resolve(text));
+        process.stdin.on('error', reject);
+        if (process.stdin.isTTY) {
+            resolve('');
+        }
+    });
+}
+
+function writeCredential(token: string) {
+    process.stdout.write(`username=vertesia\npassword=${token}\n`);
+}

packages/cli/src/profiles/index.ts

@@ -21,18 +21,11 @@ export type Region = 'us1' | 'eu1' | 'jp1';
 export const DEFAULT_REGION: Region = 'us1';
 export const AVAILABLE_REGIONS: Region[] = ['us1', 'eu1', 'jp1'];
 
-export type ConfigUrlRef = "local" | "dev-main" | "dev-preview" | "preview" | "prod" | string;
+export type ConfigUrlRef = "local" | "preview" | "prod" | string;
 export function getConfigUrl(value: ConfigUrlRef, region: Region = DEFAULT_REGION): string {
-    if (isDevDeploymentTarget(value)) {
-        return `https://${value}.ui.dev1.vertesia.io/cli`;
-    }
     switch (value) {
         case "local":
             return "https://localhost:5173/cli";
-        case "dev-main":
-            return "https://dev-main.ui.dev1.vertesia.io/cli";
-        case "dev-preview":
-            return "https://dev-preview.ui.dev1.vertesia.io/cli";
         case "preview":
             return `https://preview.cloud.${region}.vertesia.io/cli`;
         case "prod":
@@ -46,28 +39,12 @@ export function getConfigUrl(value: ConfigUrlRef, region: Region = DEFAULT_REGIO
     }
 }
 export function getServerUrls(value: ConfigUrlRef, region: Region = DEFAULT_REGION): { studio_server_url: string; zeno_server_url: string } {
-    if (isDevDeploymentTarget(value)) {
-        return {
-            studio_server_url: `https://studio-server-${value}.api.dev1.vertesia.io`,
-            zeno_server_url: `https://zeno-server-${value}.api.dev1.vertesia.io`,
-        };
-    }
     switch (value) {
         case "local":
             return {
                 studio_server_url: "http://localhost:8091",
                 zeno_server_url: "http://localhost:8092",
             };
-        case "dev-main":
-            return {
-                studio_server_url: "https://studio-server-dev-main.api.dev1.vertesia.io",
-                zeno_server_url: "https://zeno-server-dev-main.api.dev1.vertesia.io",
-            };
-        case "dev-preview":
-            return {
-                studio_server_url: "https://studio-server-dev-preview.api.dev1.vertesia.io",
-                zeno_server_url: "https://zeno-server-dev-preview.api.dev1.vertesia.io",
-            };
         case "preview":
             return {
                 studio_server_url: `https://api-preview.${region}.vertesia.io`,
@@ -83,12 +60,8 @@ export function getServerUrls(value: ConfigUrlRef, region: Region = DEFAULT_REGI
     }
 }
 
-function isDevDeploymentTarget(value: string): boolean {
-    return value.startsWith('dev-');
-}
-
 export function getCloudTypeFromConfigUrl(url: string) {
-    if (url.startsWith("https://localhost")) {
+    if (url.startsWith("http://localhost") || url.startsWith("https://localhost")) {
         return "staging";
     } else if (url.includes(".ui.dev1.vertesia.io")) {
         return "staging";

packages/cli/src/profiles/server/index.ts

@@ -187,9 +187,17 @@ export async function startConfigSession(
                     console.error("Invalid token");
                     process.exit(1);
                 }
+            } else {
+                // Empty answer — enquirer 2.x resolves with `result: ''` on Ctrl-C
+                // rather than rejecting. Without this branch the HTTP server stays
+                // open and the process hangs.
+                cleanup();
+                console.log("\nAuthentication cancelled.");
+                process.exit(130);
             }
         } catch (err: unknown) {
             // This could be thrown if the prompt is interrupted
+            cleanup();
             if (signal?.aborted) {
                 return;
             }