sitevision-cli 1.0.0-beta.12 → 1.0.0-beta.14

package/dist/utils/oauth2-auth.js

@@ -1,10 +1,13 @@
 import http from 'http';
 import crypto from 'crypto';
 import { spawn } from 'child_process';
-import { makeRequest } from './sitevision-api.js';
+import { makeRequest, summarizeErrorBody } from './sitevision-api.js';
 import { getOAuth2RefreshToken, setOAuth2RefreshToken, deleteOAuth2RefreshToken, getOAuth2ClientSecret, } from './keychain.js';
 /** Default loopback port. Fixed so a single redirect URI can be whitelisted. */
 export const DEFAULT_REDIRECT_PORT = 8137;
+// Sitevision's provider grants everything under ALL; offline_access adds the
+// refresh token so later runs log in silently.
+export const DEFAULT_SCOPES = ['ALL', 'offline_access'];
 /** Seconds to wait for the user to finish logging in before giving up. */
 const LOGIN_TIMEOUT_MS = 300_000;
 function base64url(buffer) {
@@ -36,12 +39,17 @@ async function postToken(config, params, secret) {
             // client_secret_basic when confidential; public+PKCE clients omit it.
             auth: secret ? { username: config.clientId, password: secret } : undefined,
         });
-        if (response.statusCode !== 200)
-            return null;
-        return JSON.parse(response.body.toString());
+        if (response.statusCode !== 200) {
+            return {
+                error: `Token endpoint returned ${response.statusCode}: ${summarizeErrorBody(response.body, response.headers)}`,
+            };
+        }
+        return { tokens: JSON.parse(response.body.toString()) };
     }
-    catch {
-        return null;
+    catch (error) {
+        return {
+            error: `Token request failed: ${error instanceof Error ? error.message : String(error)}`,
+        };
     }
 }
 /** OpenID configuration path (published at the issuer root once the provider is saved). */
@@ -87,14 +95,37 @@ export function openBrowser(url) {
     }
 }
 /**
- * Serve the loopback redirect once. Returns the awaited code and a `close()`
- * that shuts the server down (freeing the port) if the login is cancelled — so
- * a retry doesn't hit an EADDRINUSE on the fixed redirect port.
+ * Turn a redirect's query params into a result, prioritizing the provider's own
+ * error (the most useful reason) over a generic "no code". Exported for testing.
  */
+export function classifyRedirect(params) {
+    if (params.error) {
+        return {
+            error: `The OAuth2 provider rejected the login: ${params.errorDescription
+                ? `${params.error} — ${params.errorDescription}`
+                : params.error}`,
+        };
+    }
+    if (params.state !== params.expectedState) {
+        return {
+            error: 'State mismatch — the login response did not match this request (a stale browser tab, or the wrong window).',
+        };
+    }
+    if (params.code) {
+        return { code: params.code };
+    }
+    return { error: 'No authorization code was returned by the provider.' };
+}
+function escapeHtml(text) {
+    return text
+        .replaceAll('&', '&')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;');
+}
 function startLoopback(port, state) {
     let finish;
     let settled = false;
-    const code = new Promise(resolve => {
+    const result = new Promise(resolve => {
         finish = (value) => {
             if (settled)
                 return;
@@ -110,19 +141,29 @@ function startLoopback(port, state) {
             res.writeHead(404).end();
             return;
         }
-        const ok = url.searchParams.get('state') === state;
-        const authCode = url.searchParams.get('code');
-        const message = ok && authCode
+        const outcome = classifyRedirect({
+            expectedState: state,
+            state: url.searchParams.get('state'),
+            error: url.searchParams.get('error'),
+            errorDescription: url.searchParams.get('error_description'),
+            code: url.searchParams.get('code'),
+        });
+        const message = outcome.code
             ? 'Login complete. You can close this window and return to the terminal.'
-            : 'Login failed. Check the terminal.';
+            : `Login failed: ${outcome.error}`;
         res.writeHead(200, { 'Content-Type': 'text/html' });
-        res.end(`<!doctype html><meta charset="utf-8"><p>${message}</p>`);
-        finish(ok ? authCode : null);
+        res.end(`<!doctype html><meta charset="utf-8"><p>${escapeHtml(message)}</p>`);
+        finish(outcome);
     });
-    const timer = setTimeout(() => finish(null), LOGIN_TIMEOUT_MS);
-    server.on('error', () => finish(null));
+    const timer = setTimeout(() => finish({ error: 'Timed out waiting for the login to complete.' }), LOGIN_TIMEOUT_MS);
+    server.on('error', error => finish({
+        error: `Local login server error: ${error instanceof Error ? error.message : String(error)}`,
+    }));
     server.listen(port, '127.0.0.1');
-    return { code, close: () => finish(null) };
+    return {
+        result,
+        close: (reason) => finish({ error: reason ?? 'Login cancelled.' }),
+    };
 }
 /**
  * Start an interactive OAuth2 login. Returns the authorize URL to open and a
@@ -147,29 +188,31 @@ export function beginOAuth2Login(dev) {
     url.searchParams.set('state', state);
     url.searchParams.set('code_challenge', challenge);
     url.searchParams.set('code_challenge_method', 'S256');
-    if (config.scopes?.length) {
-        url.searchParams.set('scope', config.scopes.join(' '));
-    }
+    url.searchParams.set('scope', (config.scopes ?? DEFAULT_SCOPES).join(' '));
     const loopback = startLoopback(port, state);
     const complete = async () => {
-        const code = await loopback.code;
-        if (!code)
-            return null;
-        const tokens = await postToken(config, {
+        const redirect = await loopback.result;
+        if (redirect.error || !redirect.code) {
+            return { error: redirect.error ?? 'Login failed.' };
+        }
+        const { tokens, error } = await postToken(config, {
             grant_type: 'authorization_code',
-            code,
+            code: redirect.code,
             redirect_uri: redirectUri,
             client_id: config.clientId,
             code_verifier: verifier,
         }, secret);
-        if (!tokens?.access_token)
-            return null;
+        if (error)
+            return { error };
+        if (!tokens?.access_token) {
+            return { error: 'The token endpoint did not return an access token.' };
+        }
         if (tokens.refresh_token) {
             setOAuth2RefreshToken(domain, config.clientId, tokens.refresh_token);
         }
-        return tokens.access_token;
+        return { token: tokens.access_token };
     };
-    return { authUrl: url.href, complete, cancel: loopback.close };
+    return { authUrl: url.href, complete, cancel: () => loopback.close() };
 }
 /**
  * Silently resolve an access token by refreshing the keychain refresh token.
@@ -186,7 +229,7 @@ export async function resolveOAuth2AccessToken(dev) {
     const storedRefresh = getOAuth2RefreshToken(domain, config.clientId);
     if (!storedRefresh)
         return null;
-    const tokens = await postToken(config, {
+    const { tokens } = await postToken(config, {
         grant_type: 'refresh_token',
         refresh_token: storedRefresh,
         client_id: config.clientId,

package/dist/utils/project-detection.d.ts

@@ -22,6 +22,14 @@ export declare function findDevPropertiesPath(root: string): string | null;
  * Get the default dev properties path (for creating new files)
  */
 export declare function getDefaultDevPropertiesPath(root: string): string;
+/**
+ * The dev properties a workspace root defines (its own file merged over any
+ * ancestors'), with the deploy password resolved from the keychain like an
+ * app's would be. Used to edit shared config from the shell.
+ */
+export declare function readWorkspaceDevProperties(root: string): Partial<DevProperties>;
+/** Dev properties inherited from ancestor directories only (no own file). */
+export declare function readInheritedDevProperties(root: string): Partial<DevProperties>;
 /**
  * Get the full app ID including any prefix/suffix from environment
  *
@@ -81,12 +89,25 @@ export declare function readManifest(cwd: string): {
  * Detect if the current directory is a Sitevision project
  */
 export declare function detectProject(cwd?: string): ProjectInfo | null;
+/**
+ * Fill the runtime-only credential fields for the given domain/username:
+ * deploy password (env var > keychain), OAuth2 access token (env var), and
+ * session cookie (env var > keychain). Mutates and returns `dev`.
+ */
+export declare function resolveRuntimeSecrets(dev: DevProperties): DevProperties;
 /**
  * Validate that we're in a Sitevision project directory
  */
 export declare function requireProject(cwd?: string): ProjectInfo;
 /**
- * Get the app type (web, widget, rest)
+ * The app type (web, widget, rest, mcp), or undefined for a manifest type
+ * this CLI does not know. Display code uses this so one odd app never takes
+ * the whole shell down.
+ */
+export declare function appTypeOf(manifest: SitevisionManifest): SimpleAppType | undefined;
+/**
+ * Get the app type (web, widget, rest, mcp). Throws for unknown types, since
+ * build and deploy cannot proceed without knowing the endpoints.
  */
 export declare function getAppType(manifest: SitevisionManifest): SimpleAppType;
 /**
@@ -109,6 +130,7 @@ export declare function writeDevProperties(projectRoot: string, properties: DevP
  */
 export interface SvcConfig {
     syncPackageJson?: boolean;
+    environment?: string;
     [key: string]: unknown;
 }
 export declare function readSvcConfig(projectRoot: string): SvcConfig;

package/dist/utils/project-detection.js

@@ -2,6 +2,7 @@ import fs from 'fs';
 import path from 'path';
 import { getDeployPassword, setDeployPassword, getSessionCookie, } from './keychain.js';
 import { parseJsonc } from './jsonc.js';
+import { getLanguage } from './i18n.js';
 // =============================================================================
 // LOCALIZED TEXT
 // =============================================================================
@@ -14,7 +15,7 @@ import { parseJsonc } from './jsonc.js';
  * raw object as a React child, which Sitevision's localized manifests would
  * otherwise trigger.
  */
-export function localizedText(value, preferred = 'sv') {
+export function localizedText(value, preferred = getLanguage()) {
     if (!value)
         return '';
     if (typeof value === 'string')
@@ -61,6 +62,62 @@ export function findDevPropertiesPath(root) {
 export function getDefaultDevPropertiesPath(root) {
     return path.join(root, '.dev_properties.json');
 }
+/**
+ * Ancestor directories of `root` (outermost first) up to and including the
+ * nearest one containing `.git`, or the filesystem root. Each may carry a
+ * `.dev_properties.json` whose values the app inherits (nearest wins).
+ */
+function ancestorDirs(root) {
+    const dirs = [];
+    let dir = path.dirname(root);
+    while (true) {
+        dirs.unshift(dir);
+        if (fs.existsSync(path.join(dir, '.git')))
+            break;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return dirs;
+}
+function readDevPropertiesFile(dir) {
+    const file = findDevPropertiesPath(dir);
+    if (!file)
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(file, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The dev properties a workspace root defines (its own file merged over any
+ * ancestors'), with the deploy password resolved from the keychain like an
+ * app's would be. Used to edit shared config from the shell.
+ */
+export function readWorkspaceDevProperties(root) {
+    const merged = {
+        ...readInheritedDevProperties(root),
+        ...readDevPropertiesFile(root),
+    };
+    if (merged.domain && merged.username && !merged.password) {
+        merged.password =
+            process.env['SITEVISION_DEPLOY_PASSWORD'] ??
+                getDeployPassword(merged.domain, merged.username) ??
+                undefined;
+    }
+    return merged;
+}
+/** Dev properties inherited from ancestor directories only (no own file). */
+export function readInheritedDevProperties(root) {
+    let merged = {};
+    for (const dir of ancestorDirs(root)) {
+        merged = { ...merged, ...readDevPropertiesFile(dir) };
+    }
+    return merged;
+}
 /**
  * Get app ID configuration from environment or defaults
  */
@@ -127,6 +184,11 @@ export function getApiEndpoints(appType) {
                 addon: 'headlesscustommodule',
                 import: 'restAppImport',
             };
+        case 'mcp':
+            return {
+                addon: 'mcpServerCustomModule',
+                import: 'mcpServerImport',
+            };
     }
 }
 /**
@@ -217,52 +279,23 @@ export function detectProject(cwd = process.cwd()) {
         // Check for node_modules
         const nodeModulesPath = path.join(cwd, 'node_modules');
         const hasNodeModules = fs.existsSync(nodeModulesPath);
-        // Check for dev properties
+        // Dev properties: ancestor files (workspace root) merged under the app's
+        // own file, so shared site/auth config lives once at the repo root.
         const devPropertiesPath = findDevPropertiesPath(cwd);
+        const inherited = readInheritedDevProperties(cwd);
+        const own = devPropertiesPath ? readDevPropertiesFile(cwd) : null;
+        const inheritedKeys = Object.keys(inherited).filter(key => !own || !Object.hasOwn(own, key));
         let devProperties;
-        let hasDevProperties = false;
+        const hasDevProperties = Boolean(own) || inheritedKeys.length > 0;
         let hasLegacyPassword = false;
-        if (devPropertiesPath) {
-            hasDevProperties = true;
+        if (hasDevProperties) {
             try {
-                const parsed = JSON.parse(fs.readFileSync(devPropertiesPath, 'utf-8'));
+                const parsed = { ...inherited, ...own };
                 hasLegacyPassword =
                     typeof parsed.password === 'string' && parsed.password.length > 0;
                 devProperties = parsed;
-                // Resolve deploy password: env var > keychain (file is legacy-only)
-                if (!hasLegacyPassword &&
-                    devProperties.domain &&
-                    devProperties.username) {
-                    const envPassword = process.env['SITEVISION_DEPLOY_PASSWORD'];
-                    if (envPassword) {
-                        devProperties.password = envPassword;
-                    }
-                    else {
-                        const stored = getDeployPassword(devProperties.domain, devProperties.username);
-                        if (stored) {
-                            devProperties.password = stored;
-                        }
-                    }
-                }
-                // Resolve an OAuth2 access token: env var > keychain refresh.
-                // The env var is the manual/CI path; the interactive login stores a
-                // refresh token in the keychain and mints access tokens from it.
-                if (devProperties.authMethod === 'oauth2') {
-                    const envToken = process.env['SITEVISION_ACCESS_TOKEN'];
-                    if (envToken) {
-                        devProperties.accessToken = envToken;
-                    }
-                }
-                // Resolve a session cookie: env var > keychain (captured at login).
-                if (devProperties.authMethod === 'cookie' &&
-                    devProperties.domain &&
-                    devProperties.username) {
-                    const envCookie = process.env['SITEVISION_SESSION_COOKIE'];
-                    devProperties.sessionCookie =
-                        envCookie ??
-                            getSessionCookie(devProperties.domain, devProperties.username) ??
-                            undefined;
-                }
+                if (!hasLegacyPassword)
+                    resolveRuntimeSecrets(devProperties);
             }
             catch {
                 // Invalid dev properties file
@@ -279,6 +312,7 @@ export function detectProject(cwd = process.cwd()) {
             hasSigningProperties,
             hasLegacyPassword,
             devProperties,
+            inheritedKeys,
             packageJson,
             hasSitevisionScripts,
             hasNodeModules,
@@ -294,6 +328,29 @@ export function detectProject(cwd = process.cwd()) {
         return null;
     }
 }
+/**
+ * Fill the runtime-only credential fields for the given domain/username:
+ * deploy password (env var > keychain), OAuth2 access token (env var), and
+ * session cookie (env var > keychain). Mutates and returns `dev`.
+ */
+export function resolveRuntimeSecrets(dev) {
+    if (dev.domain && dev.username) {
+        dev.password =
+            process.env['SITEVISION_DEPLOY_PASSWORD'] ??
+                getDeployPassword(dev.domain, dev.username) ??
+                undefined;
+    }
+    if (dev.authMethod === 'oauth2') {
+        dev.accessToken = process.env['SITEVISION_ACCESS_TOKEN'] ?? undefined;
+    }
+    if (dev.authMethod === 'cookie' && dev.domain && dev.username) {
+        dev.sessionCookie =
+            process.env['SITEVISION_SESSION_COOKIE'] ??
+                getSessionCookie(dev.domain, dev.username) ??
+                undefined;
+    }
+    return dev;
+}
 /**
  * Validate that we're in a Sitevision project directory
  */
@@ -305,20 +362,31 @@ export function requireProject(cwd) {
     return project;
 }
 /**
- * Get the app type (web, widget, rest)
+ * The app type (web, widget, rest, mcp), or undefined for a manifest type
+ * this CLI does not know. Display code uses this so one odd app never takes
+ * the whole shell down.
  */
-export function getAppType(manifest) {
+export function appTypeOf(manifest) {
     const type = manifest.type.toLowerCase();
-    if (type.startsWith('web')) {
+    if (type.startsWith('web'))
         return 'web';
-    }
-    if (type.startsWith('widget')) {
+    if (type.startsWith('widget'))
         return 'widget';
-    }
-    if (type.startsWith('rest')) {
+    if (type.startsWith('rest'))
         return 'rest';
-    }
-    throw new Error(`Unknown app type: ${manifest.type}`);
+    if (type.startsWith('mcp'))
+        return 'mcp';
+    return undefined;
+}
+/**
+ * Get the app type (web, widget, rest, mcp). Throws for unknown types, since
+ * build and deploy cannot proceed without knowing the endpoints.
+ */
+export function getAppType(manifest) {
+    const type = appTypeOf(manifest);
+    if (!type)
+        throw new Error(`Unknown app type: ${manifest.type}`);
+    return type;
 }
 /**
  * Check if the app uses webpack bundling
@@ -349,8 +417,13 @@ export function readDevProperties(projectRoot) {
 export function writeDevProperties(projectRoot, properties) {
     const devPropertiesPath = findDevPropertiesPath(projectRoot) ||
         getDefaultDevPropertiesPath(projectRoot);
-    const { password: _password, accessToken: _accessToken, sessionCookie: _sessionCookie, ...persisted } = properties;
-    fs.writeFileSync(devPropertiesPath, JSON.stringify(persisted, null, 2));
+    const { password: _password, accessToken: _accessToken, sessionCookie: _sessionCookie, environmentName: _environmentName, productionEnvironment: _productionEnvironment, ...persisted } = properties;
+    // Keep the app file minimal: values identical to the inherited ones stay
+    // at the workspace root instead of being copied into every app.
+    const inherited = readInheritedDevProperties(projectRoot);
+    const own = Object.fromEntries(Object.entries(persisted).filter(([key, value]) => !Object.hasOwn(inherited, key) ||
+        JSON.stringify(inherited[key]) !== JSON.stringify(value)));
+    fs.writeFileSync(devPropertiesPath, JSON.stringify(own, null, 2));
 }
 export function readSvcConfig(projectRoot) {
     try {

package/dist/utils/sitevision-api.d.ts

@@ -109,4 +109,39 @@ export declare function createAddon(config: DeployConfig, appType: SimpleAppType
  * @param appType - The app type (web, widget, rest)
  */
 export declare function activateApp(executableId: string, config: DeployConfig, _appType: SimpleAppType): Promise<ActivationResponse>;
+/**
+ * A version uploaded to a custom module, as reported by the
+ * ActivateCustomModuleExecutable GET endpoint.
+ */
+export interface Executable {
+    id: string;
+    name: string;
+    appIdentifier: string;
+    appVersion: string;
+    active: boolean;
+}
+export interface ListExecutablesResponse {
+    success: boolean;
+    executables?: Executable[];
+    error?: string;
+    authExpired?: boolean;
+}
+/**
+ * List the executables (uploaded versions) of the configured addon.
+ */
+export declare function listExecutables(config: DeployConfig): Promise<ListExecutablesResponse>;
+export interface AddonNode {
+    id: string;
+    name: string;
+    type: string;
+    appType?: SimpleAppType;
+}
+/**
+ * List the addons (custom modules) in the site's Addon Repository.
+ */
+export declare function listAddons(config: DeployConfig): Promise<{
+    success: boolean;
+    addons?: AddonNode[];
+    error?: string;
+}>;
 export { createBasicAuth, configAuth, unauthorizedMessage };

package/dist/utils/sitevision-api.js

@@ -12,7 +12,7 @@ import fs from 'fs';
 import path from 'path';
 import https from 'https';
 import http from 'http';
-import { buildImportEndpointUrl, buildAddonEndpointUrl, } from './project-detection.js';
+import { buildImportEndpointUrl, buildAddonEndpointUrl, buildApiBaseUrl, } from './project-detection.js';
 // =============================================================================
 // CONSTANTS
 // =============================================================================
@@ -545,6 +545,79 @@ export async function activateApp(executableId, config, _appType) {
         };
     }
 }
+/**
+ * List the executables (uploaded versions) of the configured addon.
+ */
+export async function listExecutables(config) {
+    const protocol = config.useHTTP ? 'http' : 'https';
+    const url = `${protocol}://${config.domain}/rest-api/1/0/${encodeURIComponent(config.siteName)}/Addon%20Repository/${encodeURIComponent(config.addonName)}/activateCustomModuleExecutable`;
+    const { auth, kind } = configAuth(config);
+    try {
+        const response = await makeRequest(url, { method: 'GET', auth });
+        if (response.statusCode === 401) {
+            return {
+                success: false,
+                error: unauthorizedMessage(kind),
+                authExpired: true,
+            };
+        }
+        if (response.statusCode !== 200) {
+            return {
+                success: false,
+                error: `Listing versions failed with status ${response.statusCode}: ${summarizeErrorBody(response.body, response.headers)}`,
+            };
+        }
+        const data = JSON.parse(response.body.toString());
+        return { success: true, executables: data.executables ?? [] };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Listing versions failed: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+const ADDON_TYPES = {
+    'sv:customModule': 'web',
+    'sv:marketplaceCustomModule': 'web',
+    'sv:widgetCustomModule': 'widget',
+    'sv:marketplaceWidgetCustomModule': 'widget',
+    'sv:headlessCustomModule': 'rest',
+    'sv:marketplaceHeadlessCustomModule': 'rest',
+    'sv:mcpServerCustomModule': 'mcp',
+};
+/**
+ * List the addons (custom modules) in the site's Addon Repository.
+ */
+export async function listAddons(config) {
+    const url = `${buildApiBaseUrl(config.domain, config.siteName, config.useHTTP)}/Addon%20Repository/nodes`;
+    const { auth, kind } = configAuth(config);
+    try {
+        const response = await makeRequest(url, { method: 'GET', auth });
+        if (response.statusCode === 401) {
+            return { success: false, error: unauthorizedMessage(kind) };
+        }
+        if (response.statusCode !== 200) {
+            return {
+                success: false,
+                error: `Listing addons failed with status ${response.statusCode}: ${summarizeErrorBody(response.body, response.headers)}`,
+            };
+        }
+        const nodes = JSON.parse(response.body.toString());
+        return {
+            success: true,
+            addons: nodes
+                .filter(node => Object.hasOwn(ADDON_TYPES, node.type))
+                .map(node => ({ ...node, appType: ADDON_TYPES[node.type] })),
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Listing addons failed: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
 // =============================================================================
 // HELPER EXPORTS
 // =============================================================================

package/dist/utils/tasks.d.ts

@@ -0,0 +1,48 @@
+import type { ProjectInfo, SigningCredentials, DeployConfig } from '../types/index.js';
+export type TaskKind = 'dev' | 'watch' | 'build' | 'sign' | 'deploy' | 'activate' | 'install';
+export type TaskStatus = 'running' | 'success' | 'error' | 'stopped';
+export type LogLevel = 'info' | 'ok' | 'warn' | 'error';
+export interface LogLine {
+    time: number;
+    tag: string;
+    level: LogLevel;
+    text: string;
+}
+export interface Task {
+    id: number;
+    kind: TaskKind;
+    appRoot: string;
+    appName: string;
+    label: string;
+    status: TaskStatus;
+    phase: string;
+    startedAt: number;
+    endedAt?: number;
+    lines: LogLine[];
+    error?: string;
+    stop: () => void;
+}
+export declare function getTasks(): Task[];
+export declare function useTasks(): Task[];
+export declare function runningTasks(appRoot?: string): Task[];
+export declare function clearFinished(): void;
+export interface DeployOptions {
+    force?: boolean;
+    production?: boolean;
+    activate?: boolean;
+}
+export declare function startBuild(project: ProjectInfo): Task;
+export declare function startSign(project: ProjectInfo, credentials: SigningCredentials): Task;
+export declare function startDeploy(project: ProjectInfo, config: DeployConfig, options: DeployOptions): Task;
+export declare function startActivate(project: ProjectInfo, config: DeployConfig, executableId: string, versionLabel: string): Task;
+export declare function startInstall(project: ProjectInfo): Task;
+export interface DevOptions {
+    deploy: boolean;
+    signingCredentials?: SigningCredentials;
+    deployConfig?: DeployConfig;
+}
+/**
+ * Dev / watch loop: build on every source change, then optionally sign and
+ * deploy. Runs until `task.stop()`; the task stays in the registry meanwhile.
+ */
+export declare function startDev(project: ProjectInfo, options: DevOptions): Task;