@superpanel-sdk/runtime 0.2.2 → 0.5.0

package/dist/cli/auth/clipboard.js

@@ -0,0 +1,38 @@
+import { spawnSync } from 'node:child_process';
+/** Native clipboard commands, in preference order for the current platform. */
+export function clipboardCommands(platform) {
+    switch (platform) {
+        case 'darwin':
+            return [{ file: 'pbcopy', args: [] }];
+        case 'win32':
+            return [{ file: 'clip.exe', args: [] }];
+        case 'linux':
+            return [
+                { file: 'wl-copy', args: [] },
+                { file: 'xclip', args: ['-selection', 'clipboard'] },
+                { file: 'xsel', args: ['--clipboard', '--input'] },
+            ];
+        default:
+            return [];
+    }
+}
+/** Copy text without invoking a shell, so an authorization URL is always treated as plain input. */
+export function copyToClipboard(text, platform = process.platform) {
+    const commands = clipboardCommands(platform);
+    if (commands.length === 0)
+        throw new Error(`clipboard copy is not supported on ${platform}`);
+    const failures = [];
+    for (const command of commands) {
+        const result = spawnSync(command.file, command.args, {
+            input: text,
+            encoding: 'utf8',
+            stdio: ['pipe', 'ignore', 'pipe'],
+        });
+        if (!result.error && result.status === 0)
+            return;
+        const detail = result.error?.message ?? (result.stderr.trim() || `exit ${result.status}`);
+        failures.push(`${command.file}: ${detail}`);
+    }
+    throw new Error(failures.join('; '));
+}
+//# sourceMappingURL=clipboard.js.map

package/dist/cli/auth/http.d.ts

@@ -0,0 +1,20 @@
+export declare function apiUrl(backendUrl: string, path: string): string;
+export declare function requestJson<T>(url: string, init: RequestInit): Promise<{
+    response: Response;
+    payload: T & {
+        error?: string;
+    };
+}>;
+export declare function postJson<T>(url: string, body: unknown): Promise<{
+    response: Response;
+    payload: T & {
+        error?: string;
+    };
+}>;
+export declare function getJson<T>(url: string, token: string): Promise<{
+    response: Response;
+    payload: T & {
+        error?: string;
+    };
+}>;
+//# sourceMappingURL=http.d.ts.map

package/dist/cli/auth/http.js

@@ -0,0 +1,27 @@
+import { toHttpUrl } from './backend-url.js';
+export function apiUrl(backendUrl, path) {
+    const url = toHttpUrl(backendUrl);
+    url.pathname = `/api/${path.replace(/^\//, '')}`;
+    url.search = '';
+    url.hash = '';
+    return url.toString();
+}
+export async function requestJson(url, init) {
+    const response = await fetch(url, { ...init, signal: AbortSignal.timeout(15_000) });
+    const payload = (await response.json().catch(() => ({})));
+    return { response, payload };
+}
+export async function postJson(url, body) {
+    return requestJson(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+}
+export async function getJson(url, token) {
+    return requestJson(url, {
+        method: 'GET',
+        headers: { Authorization: `Bearer ${token}` },
+    });
+}
+//# sourceMappingURL=http.js.map

package/dist/cli/auth/index.d.ts

@@ -0,0 +1,10 @@
+export declare function runLogin(repoRoot: string, options: {
+    url?: string;
+}): Promise<void>;
+export declare function runLogout(repoRoot: string, options: {
+    url?: string;
+}): Promise<void>;
+export declare function runWhoami(repoRoot: string, options: {
+    url?: string;
+}): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/auth/index.js

@@ -0,0 +1,27 @@
+import { authorizeServe, cacheServeAuthorization, readServeAuthorizationStatus, removeCachedServeAuthorization, resolveBackendUrl, } from './auth.js';
+export async function runLogin(repoRoot, options) {
+    const backendUrl = resolveBackendUrl(repoRoot, options.url);
+    const authorization = await authorizeServe(backendUrl);
+    await cacheServeAuthorization(backendUrl, authorization);
+    console.log(`Logged in as ${authorization.user.email}`);
+}
+export async function runLogout(repoRoot, options) {
+    const backendUrl = resolveBackendUrl(repoRoot, options.url);
+    const removed = await removeCachedServeAuthorization(backendUrl);
+    console.log(removed ? `Logged out of ${backendUrl}` : `Not logged in to ${backendUrl}`);
+}
+export async function runWhoami(repoRoot, options) {
+    const backendUrl = resolveBackendUrl(repoRoot, options.url);
+    const status = await readServeAuthorizationStatus(backendUrl);
+    if (!status.loggedIn) {
+        console.log(`Not logged in to ${backendUrl}`);
+        return;
+    }
+    console.log(`Backend:  ${backendUrl}`);
+    console.log(`User:     ${status.authorization.user.email}`);
+    console.log(`Company:  ${status.authorization.companyId}`);
+    console.log(status.expired
+        ? `Session:  expired at ${new Date(status.expiresAt).toISOString()} (run "login" again)`
+        : `Session:  valid until ${new Date(status.expiresAt).toISOString()}`);
+}
+//# sourceMappingURL=index.js.map

package/dist/cli/auth/progress.d.ts

@@ -0,0 +1,12 @@
+export type ProgressIndicator = {
+    start(message: string): void;
+    stop(message: string): void;
+    error(message: string): void;
+};
+/**
+ * A spinner on an interactive terminal; a single echoed start message otherwise. `stop`/`error`
+ * are spinner-only cosmetic detail — dropped silently when there's no spinner, since the CLI's
+ * top-level handler already prints failures for non-interactive runs.
+ */
+export declare function progressIndicator(): ProgressIndicator;
+//# sourceMappingURL=progress.d.ts.map

package/dist/cli/auth/progress.js

@@ -0,0 +1,15 @@
+import { spinner } from '@clack/prompts';
+/**
+ * A spinner on an interactive terminal; a single echoed start message otherwise. `stop`/`error`
+ * are spinner-only cosmetic detail — dropped silently when there's no spinner, since the CLI's
+ * top-level handler already prints failures for non-interactive runs.
+ */
+export function progressIndicator() {
+    const s = process.stdout.isTTY === true ? spinner() : null;
+    return {
+        start: (message) => (s ? s.start(message) : console.log(message)),
+        stop: (message) => s?.stop(message),
+        error: (message) => s?.error(message),
+    };
+}
+//# sourceMappingURL=progress.js.map

package/dist/cli/auth/serve-login.d.ts

@@ -0,0 +1,8 @@
+import { type ServeAuthorization } from './auth.js';
+/** A fresh browser login, cached for the next run (a cache write failure only warns). */
+export declare function loginServe(backendUrl: string, options?: {
+    openBrowser?: boolean;
+}): Promise<ServeAuthorization>;
+/** Drops a token the backend rejected from the cache, so the next run logs in again. */
+export declare function forgetServeAuthorization(backendUrl: string, authorization: ServeAuthorization): Promise<void>;
+//# sourceMappingURL=serve-login.d.ts.map

package/dist/cli/auth/serve-login.js

@@ -0,0 +1,24 @@
+import { getLogger } from '../../logger.js';
+import { authorizeServe, cacheServeAuthorization, clearCachedServeAuthorization, } from './auth.js';
+const logger = getLogger(['runtime', 'auth']);
+/** A fresh browser login, cached for the next run (a cache write failure only warns). */
+export async function loginServe(backendUrl, options = {}) {
+    const authorization = await authorizeServe(backendUrl, options);
+    try {
+        await cacheServeAuthorization(backendUrl, authorization);
+    }
+    catch (error) {
+        logger.warn('could not cache serve authorization', error);
+    }
+    return authorization;
+}
+/** Drops a token the backend rejected from the cache, so the next run logs in again. */
+export async function forgetServeAuthorization(backendUrl, authorization) {
+    try {
+        await clearCachedServeAuthorization(backendUrl, authorization.token);
+    }
+    catch (error) {
+        logger.warn('could not clear cached serve authorization', error);
+    }
+}
+//# sourceMappingURL=serve-login.js.map

package/dist/cli/compile/index.js

@@ -1,6 +1,9 @@
 import path from 'node:path';
 import { compileAll } from '../../builder/compile/compile-sequence.js';
+import { typecheckRepo } from '../../builder/typecheck.js';
 export async function runCompile(repoRoot, options = {}) {
+    // The same type check as a release, before any build is written: a type error blocks both.
+    await typecheckRepo(repoRoot, (text) => console.log(text));
     const results = await compileAll(repoRoot, {
         sequenceIds: options.sequenceId ? [options.sequenceId] : undefined,
     });

package/dist/cli/config.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export declare const COMPANY_REPO_CONFIG_PATH = ".superpanel/config.json";
+declare const companyRepoConfigSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    backendUrl: z.ZodString;
+}, z.core.$strict>;
+export type CompanyRepoConfig = z.infer<typeof companyRepoConfigSchema>;
+export declare function readCompanyRepoConfig(repoRoot: string): CompanyRepoConfig | undefined;
+export {};
+//# sourceMappingURL=config.d.ts.map

package/dist/cli/config.js

@@ -0,0 +1,52 @@
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { z } from 'zod';
+import { toHttpUrl } from './auth/backend-url.js';
+export const COMPANY_REPO_CONFIG_PATH = '.superpanel/config.json';
+const companyRepoConfigSchema = z
+    .object({
+    version: z.literal(1),
+    backendUrl: z
+        .string()
+        .trim()
+        .min(1)
+        .refine((value) => {
+        try {
+            toHttpUrl(value);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }, 'must be a valid HTTP or HTTPS URL'),
+})
+    .strict();
+export function readCompanyRepoConfig(repoRoot) {
+    const file = path.join(repoRoot, COMPANY_REPO_CONFIG_PATH);
+    let raw;
+    try {
+        raw = readFileSync(file, 'utf8');
+    }
+    catch (error) {
+        const code = error && typeof error === 'object' && 'code' in error ? error.code : undefined;
+        if (code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`${COMPANY_REPO_CONFIG_PATH} is not valid JSON`);
+    }
+    const result = companyRepoConfigSchema.safeParse(value);
+    if (!result.success) {
+        const details = result.error.issues
+            .map((issue) => `${issue.path.join('.') || 'config'}: ${issue.message}`)
+            .join('; ');
+        throw new Error(`${COMPANY_REPO_CONFIG_PATH} has an invalid Superpanel configuration (${details})`);
+    }
+    return result.data;
+}
+//# sourceMappingURL=config.js.map

package/dist/cli/index.js

@@ -2,6 +2,7 @@
 import { existsSync } from 'node:fs';
 import path from 'node:path';
 import { Command } from 'commander';
+import { runLogin, runLogout, runWhoami } from './auth/index.js';
 import { runCompile } from './compile/index.js';
 import { runServe } from './serve/index.js';
 import { runTypeGen } from './type-gen/index.js';
@@ -35,19 +36,38 @@ program
     .action(async (options) => {
     await runCompile(process.cwd(), { sequenceId: options.sequence });
 });
+program
+    .command('login')
+    .description('Authorize Local Serve and cache the credential')
+    .option('--url <url>', 'Backend host URL')
+    .action(async (options) => {
+    await runLogin(process.cwd(), options);
+});
+program
+    .command('logout')
+    .description('Clear the cached Local Serve credential')
+    .option('--url <url>', 'Backend host URL')
+    .action(async (options) => {
+    await runLogout(process.cwd(), options);
+});
+program
+    .command('whoami')
+    .description('Show the cached Local Serve login')
+    .option('--url <url>', 'Backend host URL')
+    .action(async (options) => {
+    await runWhoami(process.cwd(), options);
+});
 program
     .command('serve')
-    .description('Watch local sequences and overlay them onto a backend over WebSocket')
-    .option('--url <url>', 'Backend host or overlay WebSocket URL (env SUPERPANEL_SDK_BACKEND_URL)')
-    .option('--api-key <key>', 'Company API key (env SUPERPANEL_SDK_API_KEY)')
-    .option('--company <id>', 'Company id (env SUPERPANEL_SDK_COMPANY_ID)')
-    .option('--sequence <id>', 'Serve a single sequence (default: all with slots)')
+    .description('Watch the whole repository and serve it in place of an environment\'s live release, over WebSocket')
+    .option('--url <url>', 'Backend host URL (env SUPERPANEL_SDK_BACKEND_URL)')
+    .option('--no-open', 'Copy the authorization URL to the clipboard instead of opening a browser')
+    .option('--environment <id>', 'Target non-production environment id (prompts in a terminal if omitted)')
     .action(async (options) => {
     await runServe(process.cwd(), {
         url: options.url,
-        apiKey: options.apiKey,
-        companyId: options.company,
-        sequenceIds: options.sequence ? [options.sequence] : undefined,
+        openBrowser: options.open,
+        environment: options.environment,
     });
 });
 async function main() {

package/dist/cli/serve/index.d.ts

@@ -1,9 +1,79 @@
+import type { AnyEventHandlers } from '../../core/functions/events.js';
+import type { FuncMap } from '../../core/functions/types.js';
+import { type CompanyPart, type SequenceBuild } from '../../builder/types.js';
+import type { CompiledCompanyMetadata } from '../../core/slot/schema.js';
+import { type OverlayAuthErrorMessage } from '../../dev-overlay/protocol.js';
 export type ServeOptions = {
     url?: string;
-    apiKey?: string;
-    companyId?: string;
-    sequenceIds?: string[];
+    environment?: string;
+    openBrowser?: boolean;
+};
+type LoadedSequence = {
+    build: SequenceBuild;
+    functions: FuncMap;
+    events: AnyEventHandlers;
+    generation: number;
+};
+/** The company-level functions (22 §5), compiled without code, and their implementations. */
+type LoadedCompany = {
+    part: CompanyPart;
+    /** From `schema/`, apart from any sequence: a repository with no sequence still pushes it. */
+    companyMetadata: CompiledCompanyMetadata;
+    functions: FuncMap;
 };
 export declare function overlayWebSocketUrl(raw: string): string;
+/** Not the repository's code: dependencies, git, and what compiling writes. */
+export declare function isIgnoredServePath(repoRoot: string, file: string): boolean;
+/**
+ * What a changed file recompiles (22-sequence-as-business-unit §6): a file of one sequence, that
+ * sequence; anything else (`schema/`, `resolve.ts`, shared code) can reach every sequence, so all.
+ */
+export declare function reloadScopeForPath(repoRoot: string, file: string): 'all' | {
+    sequenceId: string;
+} | null;
+export declare function loadCompany(repoRoot: string): Promise<LoadedCompany>;
+/** What a reload recompiles: the whole repository, or these sequences. */
+export type ReloadJob = {
+    all: boolean;
+    ids: Set<string>;
+};
+/**
+ * The changes waiting to be reloaded. A reload that fails keeps its scope (`fail`) for the next one,
+ * which a new file change starts (no retry on its own: the failure is in the code until it is
+ * edited); it is cleared only once a reload of it loads.
+ */
+export declare class ReloadQueue {
+    private pending;
+    private failed;
+    add(scope: 'all' | {
+        sequenceId: string;
+    }): void;
+    /** Something changed since the last reload. */
+    hasChanges(): boolean;
+    /** The next reload: the new changes plus what failed before. */
+    take(): ReloadJob;
+    fail(job: ReloadJob): void;
+}
+/** What a serve runs and pushes: the company's code and every loaded sequence. */
+export type ServeState = {
+    company: LoadedCompany;
+    sequences: Map<string, LoadedSequence>;
+};
+/**
+ * The state after a reload (`all`: the whole repository; else the sequences `ids` names), built
+ * aside: if any part fails to load it throws and the current state stays whole, never new company
+ * code with old sequences.
+ */
+export declare function reloadServeState(repoRoot: string, current: ServeState, job: {
+    all: boolean;
+    ids: Iterable<string>;
+}, generation: number): Promise<ServeState>;
+/**
+ * Push the local company build: the company's functions and every loaded sequence, as one overlay.
+ * With no sequence left it is still pushed, so the environment drops the ones it had (22 §11).
+ */
+export declare function pushOverlay(ws: Pick<WebSocket, 'send'>, company: LoadedCompany, sequences: Map<string, LoadedSequence>, generation: number): void;
+export declare function toOverlayError(message: OverlayAuthErrorMessage): Error;
 export declare function runServe(repoRoot: string, options?: ServeOptions): Promise<void>;
+export {};
 //# sourceMappingURL=index.d.ts.map