@sequenceholdings/artifact-studio 0.1.0

package/dist/api.d.ts

@@ -0,0 +1,14 @@
+export interface ApiClientOptions {
+    baseUrl: string;
+    token: string;
+}
+export declare function getJson<T>({ baseUrl, token, path }: ApiClientOptions & {
+    path: string;
+}): Promise<T>;
+export declare function getJsonOr404<T>({ baseUrl, token, path }: ApiClientOptions & {
+    path: string;
+}): Promise<T | null>;
+export declare function postJson<T>({ baseUrl, token, path, body, }: ApiClientOptions & {
+    path: string;
+    body?: unknown;
+}): Promise<T>;

package/dist/api.js

@@ -0,0 +1,49 @@
+const MAX_503_RETRIES = 5;
+const DEFAULT_RETRY_AFTER_SECONDS = 2;
+async function fetchWith503Retry(input, init) {
+    let attempt = 0;
+    while (true) {
+        const response = await fetch(input, init);
+        if (response.status !== 503 || attempt >= MAX_503_RETRIES)
+            return response;
+        const retryAfter = Number(response.headers.get('Retry-After')) || DEFAULT_RETRY_AFTER_SECONDS;
+        attempt += 1;
+        console.warn(`[artifact-studio] backend warming up (503); retrying in ${retryAfter}s (attempt ${attempt}/${MAX_503_RETRIES})`);
+        await new Promise((resolve) => setTimeout(resolve, retryAfter * 1000));
+    }
+}
+export async function getJson({ baseUrl, token, path }) {
+    const response = await fetchWith503Retry(`${baseUrl}${path}`, {
+        headers: { Authorization: `Bearer ${token}` },
+    });
+    if (!response.ok)
+        throw new Error(await responseError(response));
+    return response.json();
+}
+export async function getJsonOr404({ baseUrl, token, path }) {
+    const response = await fetchWith503Retry(`${baseUrl}${path}`, {
+        headers: { Authorization: `Bearer ${token}` },
+    });
+    if (response.status === 404)
+        return null;
+    if (!response.ok)
+        throw new Error(await responseError(response));
+    return response.json();
+}
+export async function postJson({ baseUrl, token, path, body, }) {
+    const response = await fetchWith503Retry(`${baseUrl}${path}`, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${token}`,
+            'Content-Type': 'application/json',
+        },
+        body: body === undefined ? undefined : JSON.stringify(body),
+    });
+    if (!response.ok)
+        throw new Error(await responseError(response));
+    return response.json();
+}
+async function responseError(response) {
+    const body = await response.json().catch(() => ({ detail: `HTTP ${response.status}` }));
+    return body.detail ?? body.error ?? `HTTP ${response.status}`;
+}

package/dist/auth.d.ts

@@ -0,0 +1,2 @@
+export declare function loginWithPkce(): Promise<void>;
+export declare function getAccessToken(): Promise<string | null>;

package/dist/auth.js

@@ -0,0 +1,129 @@
+import { createHash, randomBytes } from 'node:crypto';
+import { createServer } from 'node:http';
+import { spawn } from 'node:child_process';
+import { writeTokenConfig, readTokenConfig } from './config.js';
+const REDIRECT_PORT = 5099;
+const REDIRECT_URI = `http://localhost:${REDIRECT_PORT}`;
+const DEFAULT_AUTH0_DOMAIN = 'dev-n1t8ts403fp8oyxp.us.auth0.com';
+const DEFAULT_AUTH0_CLIENT_ID = 'GD9riCDWocfc66odpWBjwBiX43qqAX8r';
+const DEFAULT_AUTH0_AUDIENCE = 'https://api.studio.com';
+function envOr(name, fallback) {
+    return process.env[name]?.trim() || fallback;
+}
+function readAuth0Config() {
+    return {
+        domain: envOr('ARTIFACT_STUDIO_AUTH0_DOMAIN', DEFAULT_AUTH0_DOMAIN),
+        clientId: envOr('ARTIFACT_STUDIO_AUTH0_CLIENT_ID', DEFAULT_AUTH0_CLIENT_ID),
+        audience: envOr('ARTIFACT_STUDIO_AUTH0_AUDIENCE', DEFAULT_AUTH0_AUDIENCE),
+    };
+}
+function base64Url(input) {
+    return input.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}
+function openBrowser(url) {
+    const command = process.platform === 'darwin'
+        ? 'open'
+        : process.platform === 'win32'
+            ? 'cmd'
+            : 'xdg-open';
+    const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];
+    const child = spawn(command, args, { stdio: 'ignore', detached: true });
+    child.unref();
+}
+export async function loginWithPkce() {
+    const config = readAuth0Config();
+    const verifier = base64Url(randomBytes(32));
+    const challenge = base64Url(createHash('sha256').update(verifier).digest());
+    const authUrl = new URL(`https://${config.domain}/authorize`);
+    authUrl.searchParams.set('response_type', 'code');
+    authUrl.searchParams.set('client_id', config.clientId);
+    authUrl.searchParams.set('redirect_uri', REDIRECT_URI);
+    authUrl.searchParams.set('scope', 'openid profile email offline_access');
+    authUrl.searchParams.set('audience', config.audience);
+    authUrl.searchParams.set('code_challenge', challenge);
+    authUrl.searchParams.set('code_challenge_method', 'S256');
+    const code = await waitForCode(authUrl.toString());
+    const tokenResponse = await fetch(`https://${config.domain}/oauth/token`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            grant_type: 'authorization_code',
+            client_id: config.clientId,
+            code,
+            redirect_uri: REDIRECT_URI,
+            code_verifier: verifier,
+        }),
+    });
+    if (!tokenResponse.ok) {
+        throw new Error(`Auth0 token exchange failed: ${await tokenResponse.text()}`);
+    }
+    const tokens = await tokenResponse.json();
+    if (!tokens.refresh_token) {
+        throw new Error('No refresh token returned. Ensure Auth0 offline access is enabled.');
+    }
+    await writeTokenConfig({
+        accessToken: tokens.access_token,
+        refreshToken: tokens.refresh_token,
+        expiresAt: Date.now() + (tokens.expires_in ?? 86400) * 1000,
+    });
+}
+export async function getAccessToken() {
+    const tokens = await readTokenConfig();
+    if (!tokens.accessToken && !tokens.refreshToken)
+        return null;
+    if (tokens.accessToken && tokens.expiresAt && Date.now() < tokens.expiresAt - 60_000) {
+        return tokens.accessToken;
+    }
+    if (!tokens.refreshToken)
+        return tokens.accessToken ?? null;
+    const config = readAuth0Config();
+    const response = await fetch(`https://${config.domain}/oauth/token`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            grant_type: 'refresh_token',
+            client_id: config.clientId,
+            refresh_token: tokens.refreshToken,
+        }),
+    });
+    if (!response.ok) {
+        throw new Error('Stored refresh token is no longer valid. Run artifact-studio login again.');
+    }
+    const refreshed = await response.json();
+    await writeTokenConfig({
+        accessToken: refreshed.access_token,
+        refreshToken: refreshed.refresh_token ?? tokens.refreshToken,
+        expiresAt: Date.now() + (refreshed.expires_in ?? 86400) * 1000,
+    });
+    return refreshed.access_token;
+}
+async function waitForCode(authUrl) {
+    return new Promise((resolve, reject) => {
+        const server = createServer((req, res) => {
+            const url = new URL(req.url ?? '/', REDIRECT_URI);
+            const code = url.searchParams.get('code');
+            const error = url.searchParams.get('error');
+            if (error) {
+                res.writeHead(400, { 'content-type': 'text/plain' });
+                res.end(`Login failed: ${error}`);
+                server.close();
+                reject(new Error(`Auth0 login failed: ${error}`));
+                return;
+            }
+            if (!code) {
+                res.writeHead(400, { 'content-type': 'text/plain' });
+                res.end('Missing authorization code');
+                return;
+            }
+            res.writeHead(200, { 'content-type': 'text/html' });
+            res.end('<h1>Artifact Studio login complete</h1><p>You may close this tab.</p>');
+            server.close();
+            resolve(code);
+        });
+        server.once('error', reject);
+        server.listen(REDIRECT_PORT, () => {
+            console.log(`Opening browser for Auth0 login. If it does not open, visit:\n${authUrl}`);
+            openBrowser(authUrl);
+        });
+    });
+}

package/dist/build.d.ts

@@ -0,0 +1,12 @@
+import { type ArtifactStudioSourceFile } from './project.js';
+import type { ArtifactStudioManifest } from './manifest.js';
+export interface ArtifactStudioBuildResult {
+    manifest: ArtifactStudioManifest;
+    files: ArtifactStudioSourceFile[];
+    bundle: string;
+    sourceMap: string | null;
+    sourceHash: string;
+    bundleHash: string;
+}
+export declare function buildArtifactStudioProject(rootDir: string): Promise<ArtifactStudioBuildResult>;
+export declare function writeBuildArtifact(result: ArtifactStudioBuildResult, outPath: string): Promise<void>;

package/dist/build.js

@@ -0,0 +1,134 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { build as viteBuild } from 'vite';
+import { sha256Hex } from './hash.js';
+import { readArtifactStudioSource } from './project.js';
+const cliRequire = createRequire(import.meta.url);
+const cliDir = dirname(fileURLToPath(import.meta.url));
+const reactDir = dirname(cliRequire.resolve('react/package.json'));
+const reactDomDir = dirname(cliRequire.resolve('react-dom/package.json'));
+const atlasUiDir = dirname(cliRequire.resolve('@sequenceholdings/atlas-ui/package.json'));
+const atlasUiDist = resolve(atlasUiDir, 'dist');
+const tailwindCssPath = resolve(dirname(cliRequire.resolve('tailwindcss/package.json')), 'index.css');
+const twAnimateCssPath = resolve(cliDir, '..', 'node_modules', 'tw-animate-css', 'dist', 'tw-animate.css');
+function isAssetOutput(value) {
+    return value.type === 'asset';
+}
+export async function buildArtifactStudioProject(rootDir) {
+    const source = await readArtifactStudioSource(rootDir);
+    const root = source.root;
+    const result = await viteBuild({
+        root,
+        configFile: false,
+        logLevel: 'silent',
+        plugins: [
+            artifactSdkVirtualModule(),
+            atlasUiCssResolverPlugin(),
+            (await import('@tailwindcss/vite')).default(),
+        ],
+        resolve: {
+            alias: {
+                react: reactDir,
+                'react-dom/client': resolve(reactDomDir, 'client'),
+                'react-dom': reactDomDir,
+                '@sequenceholdings/atlas-ui/tokens.css': resolve(atlasUiDist, 'tokens.css'),
+                '@sequenceholdings/atlas-ui/charts': resolve(atlasUiDist, 'charts.mjs'),
+                '@sequenceholdings/atlas-ui': resolve(atlasUiDist, 'index.mjs'),
+            },
+        },
+        build: {
+            write: false,
+            sourcemap: true,
+            cssCodeSplit: false,
+            assetsInlineLimit: Number.MAX_SAFE_INTEGER,
+            rollupOptions: {
+                input: resolve(root, 'index.html'),
+                output: {
+                    format: 'iife',
+                    inlineDynamicImports: true,
+                    name: 'ArtifactStudioApp',
+                },
+            },
+        },
+    });
+    const output = Array.isArray(result) ? result.flatMap((r) => r.output) : result.output;
+    const js = collectEntryJavaScript(output);
+    if (!js)
+        throw new Error('Build produced no JavaScript output');
+    const css = collectCss(output);
+    const bundle = css ? injectCssRuntime(css) + '\n' + js : js;
+    return {
+        manifest: source.manifest,
+        files: source.files,
+        sourceHash: source.sourceHash,
+        bundle,
+        sourceMap: collectSourceMap(output),
+        bundleHash: sha256Hex(bundle),
+    };
+}
+export async function writeBuildArtifact(result, outPath) {
+    const target = resolve(outPath);
+    await mkdir(dirname(target), { recursive: true });
+    await writeFile(target, JSON.stringify(result, null, 2) + '\n', 'utf8');
+}
+function artifactSdkVirtualModule() {
+    const virtualIds = new Set(['@sequence/artifact-sdk', '@sequenceholdings/artifact-studio']);
+    const resolved = '\0sequence-artifact-sdk';
+    return {
+        name: 'sequence-artifact-sdk',
+        resolveId(id) {
+            return virtualIds.has(id) ? resolved : undefined;
+        },
+        load(id) {
+            if (id !== resolved)
+                return undefined;
+            return 'export const seq = window.seq; export default window.seq;';
+        },
+    };
+}
+function collectEntryJavaScript(output) {
+    const entryChunks = output.filter((chunk) => chunk.type === 'chunk' && chunk.isEntry);
+    if (entryChunks.length === 0)
+        return null;
+    return entryChunks.map((chunk) => chunk.code).join('\n');
+}
+function collectCss(output) {
+    const cssAssets = output.filter((chunk) => isAssetOutput(chunk) && chunk.fileName.endsWith('.css'));
+    if (cssAssets.length === 0)
+        return null;
+    return cssAssets.map((asset) => String(asset.source)).join('\n');
+}
+function injectCssRuntime(css) {
+    return `(() => {
+    const style = document.createElement('style');
+    style.textContent = ${JSON.stringify(css)};
+    document.head.appendChild(style);
+  })();`;
+}
+function collectSourceMap(output) {
+    const maps = output
+        .filter((chunk) => chunk.type === 'chunk' && !!chunk.map)
+        .map((chunk) => ({ fileName: chunk.fileName, map: chunk.map }));
+    return maps.length > 0 ? JSON.stringify(maps) : null;
+}
+function atlasUiCssResolverPlugin() {
+    return {
+        name: 'atlas-ui-css-resolver',
+        enforce: 'pre',
+        transform(code, id) {
+            if (!id.endsWith('.css'))
+                return undefined;
+            let result = code;
+            if (result.includes('@import "tailwindcss"')) {
+                result = result.replace('@import "tailwindcss"', `@import ${JSON.stringify(tailwindCssPath)}`);
+                result = `@source ${JSON.stringify(atlasUiDist)};\n${result}`;
+            }
+            if (result.includes('@import "tw-animate-css"')) {
+                result = result.replace('@import "tw-animate-css"', `@import ${JSON.stringify(twAnimateCssPath)}`);
+            }
+            return result !== code ? result : undefined;
+        },
+    };
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function runCli(argv?: string[]): Promise<number>;