@sequenceholdings/artifact-studio 0.1.11 → 0.1.15

package/dist/api.js

@@ -1,3 +1,4 @@
+import { authenticatedRequestUrl } from './deployment-validation.js';
 const MAX_503_RETRIES = 5;
 const DEFAULT_RETRY_AFTER_SECONDS = 2;
 /**
@@ -47,18 +48,26 @@ async function fetchWith503Retry(input, init) {
         await new Promise((resolve) => setTimeout(resolve, retryAfter * 1000));
     }
 }
-export async function getJson({ baseUrl, token, path }) {
-    const response = await fetchWith503Retry(`${baseUrl}${path}`, {
-        headers: { ...extraHeaders(), Authorization: `Bearer ${token}` },
+async function authenticatedFetch({ baseUrl, init = {}, path, token, }) {
+    const url = authenticatedRequestUrl({ baseUrl, path });
+    return fetchWith503Retry(url, {
+        ...init,
+        redirect: 'manual',
+        headers: {
+            ...extraHeaders(),
+            ...init.headers,
+            Authorization: `Bearer ${token}`,
+        },
     });
+}
+export async function getJson({ baseUrl, token, path }) {
+    const response = await authenticatedFetch({ baseUrl, token, path });
     if (!response.ok)
         throw new Error(await responseError('GET', path, response));
     return response.json();
 }
 export async function getJsonOr404({ baseUrl, token, path }) {
-    const response = await fetchWith503Retry(`${baseUrl}${path}`, {
-        headers: { ...extraHeaders(), Authorization: `Bearer ${token}` },
-    });
+    const response = await authenticatedFetch({ baseUrl, token, path });
     if (response.status === 404)
         return null;
     if (!response.ok)
@@ -66,14 +75,15 @@ export async function getJsonOr404({ baseUrl, token, path }) {
     return response.json();
 }
 export async function postJson({ baseUrl, token, path, body, }) {
-    const response = await fetchWith503Retry(`${baseUrl}${path}`, {
-        method: 'POST',
-        headers: {
-            ...extraHeaders(),
-            Authorization: `Bearer ${token}`,
-            'Content-Type': 'application/json',
+    const response = await authenticatedFetch({
+        baseUrl,
+        token,
+        path,
+        init: {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: body === undefined ? undefined : JSON.stringify(body),
         },
-        body: body === undefined ? undefined : JSON.stringify(body),
     });
     if (!response.ok)
         throw new Error(await responseError('POST', path, response));

package/dist/build-subprocess.d.ts

@@ -4,6 +4,8 @@ export interface IsolatedBuildOptions {
     workerPath?: string;
     /** Abort to kill the in-flight build child (e.g. on watcher shutdown). */
     signal?: AbortSignal;
+    /** Parent environment override for deterministic security tests. */
+    sourceEnv?: NodeJS.ProcessEnv;
 }
 /**
  * Run a single artifact build in a short-lived child process and return its
@@ -12,4 +14,4 @@ export interface IsolatedBuildOptions {
  * long-running watch loops; one-shot commands can call
  * `buildArtifactStudioProject` directly.
  */
-export declare function buildArtifactStudioProjectIsolated(dir: string, { workerPath, signal }?: IsolatedBuildOptions): Promise<ArtifactStudioBuildResult>;
+export declare function buildArtifactStudioProjectIsolated(dir: string, { workerPath, signal, sourceEnv }?: IsolatedBuildOptions): Promise<ArtifactStudioBuildResult>;

package/dist/build-subprocess.js

@@ -1,9 +1,15 @@
 import { spawn } from 'node:child_process';
-import { mkdtemp, readFile, rm } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { mkdir, mkdtemp, readFile, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
-const DEFAULT_WORKER_PATH = join(dirname(fileURLToPath(import.meta.url)), 'build-worker.js');
+import { createScrubbedChildEnv } from './child-environment.js';
+const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
+const BUILT_WORKER_PATH = join(MODULE_DIR, 'build-worker.js');
+const DEFAULT_WORKER_PATH = existsSync(BUILT_WORKER_PATH)
+    ? BUILT_WORKER_PATH
+    : join(MODULE_DIR, 'build-worker.ts');
 /**
  * Run a single artifact build in a short-lived child process and return its
  * result. The child exits as soon as the build finishes, so the OS reclaims
@@ -11,25 +17,41 @@ const DEFAULT_WORKER_PATH = join(dirname(fileURLToPath(import.meta.url)), 'build
  * long-running watch loops; one-shot commands can call
  * `buildArtifactStudioProject` directly.
  */
-export async function buildArtifactStudioProjectIsolated(dir, { workerPath = DEFAULT_WORKER_PATH, signal } = {}) {
+export async function buildArtifactStudioProjectIsolated(dir, { workerPath = DEFAULT_WORKER_PATH, signal, sourceEnv } = {}) {
     const scratch = await mkdtemp(join(tmpdir(), 'artifact-build-'));
     const outFile = join(scratch, 'result.json');
+    const homeDir = join(scratch, 'home');
     try {
-        await runWorker({ workerPath, dir, outFile, signal });
+        await mkdir(homeDir, { recursive: true });
+        await runWorker({
+            workerPath,
+            dir,
+            outFile,
+            homeDir,
+            signal,
+            ...(sourceEnv ? { sourceEnv } : {}),
+        });
         return JSON.parse(await readFile(outFile, 'utf8'));
     }
     finally {
         await rm(scratch, { recursive: true, force: true });
     }
 }
-function runWorker({ workerPath, dir, outFile, signal, }) {
+function runWorker({ workerPath, dir, outFile, homeDir, signal, sourceEnv, }) {
     return new Promise((resolve, reject) => {
         if (signal?.aborted) {
             reject(new Error('build aborted'));
             return;
         }
-        const child = spawn(process.execPath, [workerPath, dir, outFile], {
+        const workerArgs = workerPath.endsWith('.ts')
+            ? ['--import', 'tsx', workerPath, dir, outFile]
+            : [workerPath, dir, outFile];
+        const child = spawn(process.execPath, workerArgs, {
             stdio: ['ignore', 'inherit', 'pipe'],
+            env: createScrubbedChildEnv({
+                homeDir,
+                ...(sourceEnv ? { source: sourceEnv } : {}),
+            }),
         });
         const onAbort = () => {
             child.kill('SIGTERM');

package/dist/child-environment.d.ts

@@ -0,0 +1,5 @@
+export declare function createScrubbedChildEnv({ homeDir, source, additionalEnv, }: {
+    homeDir: string;
+    source?: NodeJS.ProcessEnv;
+    additionalEnv?: NodeJS.ProcessEnv;
+}): NodeJS.ProcessEnv;

package/dist/child-environment.js

@@ -0,0 +1,83 @@
+import { join } from 'node:path';
+// This prevents ambient credential inheritance and conventional HOME/config
+// discovery. It is not an OS sandbox: the child still has the caller's uid and
+// can read explicitly named filesystem paths and, where the OS permits it,
+// inspect other same-uid processes (for example through Linux /proc).
+const SAFE_CHILD_ENV_NAMES = new Set([
+    'PATH',
+    'PATHEXT',
+    'SYSTEMROOT',
+    'WINDIR',
+    'COMSPEC',
+    'TMPDIR',
+    'TMP',
+    'TEMP',
+    'LANG',
+    'LANGUAGE',
+    'LC_ALL',
+    'TERM',
+    'COLORTERM',
+    'NO_COLOR',
+    'FORCE_COLOR',
+    'CI',
+    'TZ',
+    'SOURCE_DATE_EPOCH',
+    'SSL_CERT_FILE',
+    'SSL_CERT_DIR',
+    'NODE_EXTRA_CA_CERTS',
+]);
+const PROXY_ENV_NAMES = new Set(['HTTP_PROXY', 'HTTPS_PROXY', 'ALL_PROXY', 'NO_PROXY']);
+export function createScrubbedChildEnv({ homeDir, source = process.env, additionalEnv = {}, }) {
+    const env = {};
+    for (const [name, value] of Object.entries(source)) {
+        if (value === undefined)
+            continue;
+        const normalized = name.toUpperCase();
+        if (PROXY_ENV_NAMES.has(normalized)) {
+            env[name] = value;
+            continue;
+        }
+        if (SAFE_CHILD_ENV_NAMES.has(normalized) || normalized.startsWith('LC_')) {
+            env[name] = value;
+        }
+    }
+    Object.assign(env, additionalEnv);
+    for (const [name, value] of Object.entries(env)) {
+        if (value !== undefined && PROXY_ENV_NAMES.has(name.toUpperCase())) {
+            assertProxySettingIsSafe({ name, value });
+        }
+    }
+    return {
+        ...env,
+        HOME: homeDir,
+        USERPROFILE: homeDir,
+        XDG_CONFIG_HOME: join(homeDir, '.config'),
+        XDG_CACHE_HOME: join(homeDir, '.cache'),
+        XDG_DATA_HOME: join(homeDir, '.local', 'share'),
+        APPDATA: join(homeDir, 'AppData', 'Roaming'),
+        LOCALAPPDATA: join(homeDir, 'AppData', 'Local'),
+        USER: 'sequence-build',
+        USERNAME: 'sequence-build',
+        LOGNAME: 'sequence-build',
+    };
+}
+function assertProxySettingIsSafe({ name, value, }) {
+    if (name.toUpperCase() === 'NO_PROXY')
+        return;
+    let proxyUrl;
+    try {
+        // git/npm accept the legacy credential-free `host:port` form. Prefix a
+        // scheme for validation only; preserve the caller's exact value below.
+        proxyUrl = new URL(value.includes('://') ? value : `http://${value}`);
+    }
+    catch {
+        throw new Error(`${name} must be a valid proxy endpoint before it can be forwarded to a build worker`);
+    }
+    if (proxyUrl.username ||
+        proxyUrl.password ||
+        proxyUrl.search ||
+        proxyUrl.hash ||
+        (proxyUrl.pathname !== '' && proxyUrl.pathname !== '/')) {
+        throw new Error(`${name} contains credential-bearing URL components and cannot be forwarded to source-controlled build tooling`);
+    }
+}

package/dist/cli.d.ts

@@ -1,2 +1,17 @@
+import { type SourceAuthMode } from './source-resolver.js';
 export declare function runCli(argv?: string[]): Promise<number>;
-export declare function setTokenProvider(provider: (() => Promise<string | null>) | null): void;
+export declare function getConfiguredDefaultEnv(): Promise<string | undefined>;
+/**
+ * Optional refreshing token provider, injected by an embedder (e.g. seq-studio)
+ * that owns the shared seqapi session and can resolve an access token on
+ * demand. Authentication is owned by the embedding `seq-studio` CLI; this
+ * package deliberately has no bearer-token argv or environment escape hatch.
+ */
+export interface TokenProviderOptions {
+    allowInteractiveLogin: boolean;
+}
+export interface ProvidedToken {
+    authMode: SourceAuthMode;
+    token: string;
+}
+export declare function setTokenProvider(provider: ((options: TokenProviderOptions) => Promise<ProvidedToken | null>) | null): void;

package/dist/cli.js

@@ -3,21 +3,20 @@ import { existsSync } from 'node:fs';
 import { dirname, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { getJson, getJsonOr404, postJson } from './api.js';
-import { ENV_URLS, readLocalConfig, resolveEnvironment, writeLocalConfig, writeTokenConfig, } from './config.js';
-import { buildArtifactStudioProject, writeBuildArtifact } from './build.js';
+import { ENV_URLS, readLocalConfig, resolveEnvironment, writeLocalConfig, } from './config.js';
+import { writeBuildArtifact } from './build.js';
 import { buildArtifactStudioProjectIsolated } from './build-subprocess.js';
 import { prepareArtifactBuildRoot } from './prepare-build.js';
 import { parseArtifactStudioManifest } from './manifest.js';
 import { hasArtifactStudioManifest, readArtifactStudioSource } from './project.js';
 import { localGitMetadata, parseSourceSpec, resolveArtifactSource, } from './source-resolver.js';
-import { getAccessToken, loginWithPkce } from './auth.js';
 import { acquireDevLock } from './dev-lock.js';
 import { runWatchLoop } from './watch-loop.js';
 import { hashLinkedSources, parseLinks, rebuildLinkedDep, resolveLinkedDeps, syncLinkedDist, } from './dev-link.js';
 import { lintArtifactSandbox, reportSandboxWarnings } from './sandbox-lint.js';
 import yaml from 'js-yaml';
 const COMMANDS = [
-    'init', 'login', 'logout', 'whoami', 'link', 'env', 'status', 'list', 'show',
+    'init', 'whoami', 'link', 'env', 'status', 'list', 'show',
     'validate', 'build', 'plan', 'deploy', 'dev', 'promote', 'pull', 'rollback',
 ];
 const USAGE = `usage:
@@ -38,18 +37,24 @@ const USAGE = `usage:
   seq-studio artifact rollback <deployment-id> --env <env>
 
   Source: a local [dir] (default), a platform git-service repo (--repo <ns>/<name>),
-  or any git URL (--git-url <url>). --ref picks a branch/tag/commit (default: the
+  or a public HTTPS git URL (--git-url <url>). --ref picks a branch/tag/commit (default: the
   repo's default branch). The target project comes from the source's
   artifact.bundle.yml project_id.
 
-  --repo clones over smart-HTTP and REQUIRES a git PAT in ATLAS_GIT_PAT
-  (repo:read scope) — create one with \`seq-studio auth pat create --scopes
-  repo:read\` or in Atlas → Settings → Tokens. It's the same token you clone the
-  repo with. (--env + seq-studio login are still needed to resolve the repo and
-  upload the deployment.)
+  Interactive --repo builds clone over smart-HTTP and require a repo:read git
+  PAT in ATLAS_GIT_PAT — create one with \`seq-studio auth pat create --scopes
+  repo:read\` or in Atlas → Settings → Tokens. Headless M2M builds use JSON
+  materialize and accept only platform-managed --repo sources. (--env +
+  seq-studio login are still needed to resolve the repo and upload the
+  deployment.)
 
   Authenticate with: seq-studio login`;
 export async function runCli(argv = process.argv.slice(2)) {
+    if (argv.some((arg) => arg === '--token' || arg.startsWith('--token='))) {
+        console.error('Artifact Studio does not accept --token bearer injection. ' +
+            'Authenticate with seq-studio login.');
+        return 1;
+    }
     const parsed = parseArgs(argv);
     if ('error' in parsed) {
         console.error(parsed.error);
@@ -57,8 +62,6 @@ export async function runCli(argv = process.argv.slice(2)) {
     }
     switch (parsed.command) {
         case 'init': return initCommand(parsed);
-        case 'login': return loginCommand(parsed);
-        case 'logout': return logoutCommand();
         case 'whoami': return whoamiCommand(parsed);
         case 'link': return linkCommand(parsed);
         case 'env': return envCommand(parsed);
@@ -119,22 +122,6 @@ async function initCommand(args) {
     console.log('Next: seq-studio login && seq-studio artifact dev --env <env>  (see: seq-studio envs list)');
     return 0;
 }
-async function loginCommand(args) {
-    const token = typeof args.flags.token === 'string' ? args.flags.token : undefined;
-    if (token) {
-        await writeTokenConfig({ accessToken: token });
-        console.log('[seq-studio] saved access token');
-        return 0;
-    }
-    await loginWithPkce();
-    console.log('[seq-studio] logged in');
-    return 0;
-}
-async function logoutCommand() {
-    await writeTokenConfig({});
-    console.log('[seq-studio] logged out');
-    return 0;
-}
 async function whoamiCommand(args) {
     const env = await envFromArgs(args);
     const token = await getRequiredToken(args);
@@ -345,15 +332,23 @@ async function validateCommand(args) {
 }
 async function buildPreparedArtifactSource(source) {
     await prepareArtifactBuildRoot(source.dir, { remote: source.remote });
-    return buildArtifactStudioProject(source.dir);
+    return buildArtifactStudioProjectIsolated(source.dir);
 }
 async function buildCommand(args) {
     const spec = parseSourceSpec(args);
-    // build is offline for a local/git-url source; only a git-service source
-    // needs an env + token to fetch the tree.
-    const remote = spec.kind === 'git-service'
-        ? { baseUrl: (await envFromArgs(args)).url, token: await getRequiredToken(args) }
-        : {};
+    // Local builds stay offline. Public git URLs need no bearer token, but an
+    // optional auth lookup still identifies a selected M2M principal so the
+    // source policy can reject arbitrary CI input before cloning.
+    const auth = spec.kind === 'git-service'
+        ? await getRequiredAuth(args)
+        : spec.kind === 'git-url'
+            ? await getOptionalAuth(args)
+            : null;
+    const remote = spec.kind === 'git-service' && auth
+        ? { authMode: auth.authMode, baseUrl: (await envFromArgs(args)).url, token: auth.token }
+        : auth
+            ? { authMode: auth.authMode }
+            : {};
     const source = await resolveArtifactSource(spec, remote);
     try {
         const result = await buildPreparedArtifactSource(source);
@@ -375,9 +370,14 @@ async function buildCommand(args) {
 }
 async function planCommand(args) {
     const env = await envFromArgs(args);
-    const token = await getOptionalToken(args);
+    const auth = await getOptionalAuth(args);
+    const token = auth?.token ?? null;
     const spec = parseSourceSpec(args);
-    const source = await resolveArtifactSource(spec, { baseUrl: env.url, token });
+    const source = await resolveArtifactSource(spec, {
+        ...(auth ? { authMode: auth.authMode } : {}),
+        baseUrl: env.url,
+        token,
+    });
     try {
         const result = await buildPreparedArtifactSource(source);
         console.log(`[seq-studio] plan ${result.manifest.artifact.project_id} -> ${env.name}`);
@@ -402,10 +402,15 @@ async function planCommand(args) {
 }
 async function deployCommand(args) {
     const env = await envFromArgs(args);
-    const token = await getRequiredToken(args);
+    const auth = await getRequiredAuth(args);
+    const { token } = auth;
     const spec = parseSourceSpec(args);
     const explicitProjectId = typeof args.flags.project === 'string' ? args.flags.project : null;
-    const source = await resolveArtifactSource(spec, { baseUrl: env.url, token });
+    const source = await resolveArtifactSource(spec, {
+        authMode: auth.authMode,
+        baseUrl: env.url,
+        token,
+    });
     try {
         // --skip-unchanged: hash the raw source (no build needed) and no-op when
         // the remote active deployment already matches. Lets CI redeploy every
@@ -436,6 +441,7 @@ async function deployCommand(args) {
             linkConfigDir: spec.kind === 'local' ? source.dir : null,
             allowCreate: args.flags['no-create'] !== true,
             explicitProjectId,
+            envName: env.name,
         });
         const deployment = await uploadDeployment({ env: env.url, token, projectId: project.id, result, channel: 'active', provenance: source.provenance });
         console.log(`[seq-studio] deployed ${project.title} ${deployment.version}`);
@@ -520,7 +526,9 @@ async function devCommand(args) {
         // Resolve per push so the token refreshes across a long watch session.
         const token = await getRequiredToken(args);
         if (!projectId) {
-            const project = await ensureRemoteProject({ env: env.url, token, result, linkConfigDir: dir });
+            // envName so a first-time `artifact dev` creation honors the manifest
+            // visibility too (and notes drift, once, when the project pre-exists).
+            const project = await ensureRemoteProject({ env: env.url, token, result, linkConfigDir: dir, envName: env.name });
             projectId = project.id;
         }
         const deployment = await uploadDeployment({
@@ -684,7 +692,21 @@ async function rollbackCommand(args) {
     console.log(`[seq-studio] rolled back to ${deploymentId}`);
     return 0;
 }
-async function ensureRemoteProject({ env, token, result, linkConfigDir, allowCreate = true, explicitProjectId = null }) {
+/**
+ * Deploys never change a live project's visibility — the Studio sharing UI /
+ * PATCH own that. The manifest's targets.<env>.visibility is honored at
+ * project CREATION only; on drift, say so instead of silently ignoring the
+ * field (which is how it read as decorative for a year).
+ */
+function warnOnVisibilityDrift({ project, declared, envName }) {
+    if (!declared || !envName || !project.visibility || declared === project.visibility)
+        return;
+    console.warn(`[seq-studio] note: artifact.bundle.yml targets.${envName}.visibility is "${declared}" but the project is ` +
+        `"${project.visibility}" on this environment — deploys never change visibility. Update it in Studio sharing ` +
+        `(or PATCH /api/artifact-studio/projects/${project.id}) if the manifest is what you intend.`);
+}
+async function ensureRemoteProject({ env, token, result, linkConfigDir, allowCreate = true, explicitProjectId = null, envName = null }) {
+    const declaredVisibility = envName ? result.manifest.targets?.[envName]?.visibility : undefined;
     if (explicitProjectId) {
         const data = await getJsonOr404({ baseUrl: env, token, path: `/api/artifact-studio/projects/${explicitProjectId}` });
         if (!data)
@@ -693,19 +715,23 @@ async function ensureRemoteProject({ env, token, result, linkConfigDir, allowCre
             throw new Error(`--project ${explicitProjectId} resolves to slug "${data.project.slug}" but this source's ` +
                 `artifact.bundle.yml declares project_id "${result.manifest.artifact.project_id}" — refusing to deploy over a different project`);
         }
+        warnOnVisibilityDrift({ project: data.project, declared: declaredVisibility, envName });
         return data.project;
     }
     const config = linkConfigDir ? await readLocalConfig(linkConfigDir) : {};
     if (config.projectId) {
         const data = await getJsonOr404({ baseUrl: env, token, path: `/api/artifact-studio/projects/${config.projectId}` });
-        if (data)
+        if (data) {
+            warnOnVisibilityDrift({ project: data.project, declared: declaredVisibility, envName });
             return data.project;
+        }
         console.warn(`[seq-studio] cached projectId ${config.projectId} not found on ${env} — relinking by slug`);
     }
     const existing = await fetchRemoteProject({ env, token, slug: result.manifest.artifact.project_id });
     if (existing) {
         if (linkConfigDir)
             await writeLocalConfig({ ...config, projectId: existing.id, projectSlug: existing.slug }, linkConfigDir);
+        warnOnVisibilityDrift({ project: existing, declared: declaredVisibility, envName });
         return existing;
     }
     if (!allowCreate) {
@@ -721,6 +747,7 @@ async function ensureRemoteProject({ env, token, result, linkConfigDir, allowCre
             title: result.manifest.artifact.title,
             slug: result.manifest.artifact.project_id,
             description: result.manifest.artifact.description ?? null,
+            ...(declaredVisibility ? { visibility: declaredVisibility } : {}),
         },
     });
     if (linkConfigDir)
@@ -771,38 +798,36 @@ async function fetchRemoteProject({ env, token, slug, disambiguator }) {
     }
     return matches[0] ?? null;
 }
-async function envFromArgs(args) {
+export async function getConfiguredDefaultEnv() {
     const config = await readLocalConfig().catch(() => ({ defaultEnv: undefined }));
-    return resolveEnvironment(typeof args.flags.env === 'string' ? args.flags.env : undefined, config.defaultEnv);
+    return config.defaultEnv;
+}
+async function envFromArgs(args) {
+    return resolveEnvironment(typeof args.flags.env === 'string' ? args.flags.env : undefined, await getConfiguredDefaultEnv());
 }
-/**
- * Optional refreshing token provider, injected by an embedder (e.g. seq-studio)
- * that owns the shared seqapi token file and can mint a fresh access token on
- * demand. Consulted before the static ARTIFACT_STUDIO_TOKEN env var so a
- * long-running `dev` watcher keeps deploying past the initial token's TTL —
- * the env var is captured once at process start and never refreshes.
- */
 let tokenProvider = null;
 export function setTokenProvider(provider) {
     tokenProvider = provider;
 }
-async function getRequiredToken(args) {
-    const token = await getOptionalToken(args);
-    if (!token)
-        throw new Error('Missing token. Run seq-studio login or pass --token.');
-    return token;
+async function getRequiredToken(_args) {
+    return (await getRequiredAuth(_args)).token;
+}
+async function getRequiredAuth(_args) {
+    const auth = await resolveAuth({ allowInteractiveLogin: true });
+    if (!auth)
+        throw new Error('Missing token. Authenticate with seq-studio login.');
+    return auth;
+}
+async function getOptionalAuth(_args) {
+    return resolveAuth({ allowInteractiveLogin: false });
 }
-async function getOptionalToken(args) {
-    if (typeof args.flags.token === 'string')
-        return args.flags.token;
+async function resolveAuth(options) {
     if (tokenProvider) {
-        const provided = await tokenProvider();
+        const provided = await tokenProvider(options);
         if (provided)
             return provided;
     }
-    if (process.env.ARTIFACT_STUDIO_TOKEN)
-        return process.env.ARTIFACT_STUDIO_TOKEN;
-    return getAccessToken();
+    return null;
 }
 async function replaceInFile(path, pattern, value) {
     const content = await import('node:fs/promises').then((fs) => fs.readFile(path, 'utf8'));
@@ -831,4 +856,4 @@ function warnIfInlinedManifestDriftsFromBundle(result) {
 // This module is a pure library export. `seq-studio artifact` imports
 // `runCli` from `@sequenceholdings/artifact-studio/cli` (see
 // shared/services/studio-cli/README.md) and invokes it after injecting a
-// shared base URL + Bearer token.
+// shared base URL + internal token provider.

package/dist/config.d.ts

@@ -11,19 +11,10 @@ export interface LocalProjectConfig {
     defaultEnv?: string;
     previewKey?: string;
 }
-export interface TokenConfig {
-    accessToken?: string;
-    refreshToken?: string;
-    expiresAt?: number;
-}
-export declare function globalConfigDir(): string;
-export declare function tokenConfigPath(): string;
 export declare function localConfigPath(cwd?: string): string;
 export declare function devLockPath(cwd?: string): string;
 export declare function readLocalConfig(cwd?: string): Promise<LocalProjectConfig>;
 export declare function writeLocalConfig(config: LocalProjectConfig, cwd?: string): Promise<void>;
-export declare function readTokenConfig(): Promise<TokenConfig>;
-export declare function writeTokenConfig(config: TokenConfig): Promise<void>;
 export declare function knownEnvUrls(): Record<string, string>;
 export declare function resolveEnvironment(name: string | undefined, fallback?: string): {
     name: string;

package/dist/config.js

@@ -1,7 +1,6 @@
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
-import { homedir } from 'node:os';
 /**
  * Only `local` ships in the published package. Deployed-environment URLs
  * are resolved by the embedding CLI (seq-studio), which discovers the
@@ -11,12 +10,6 @@ import { homedir } from 'node:os';
 export const ENV_URLS = {
     local: 'http://localhost:5001',
 };
-export function globalConfigDir() {
-    return join(homedir(), '.config', 'sequence-artifact-studio');
-}
-export function tokenConfigPath() {
-    return join(globalConfigDir(), 'tokens.json');
-}
 export function localConfigPath(cwd = process.cwd()) {
     return join(resolve(cwd), '.artifact-studio', 'config.json');
 }
@@ -34,17 +27,6 @@ export async function writeLocalConfig(config, cwd = process.cwd()) {
     await mkdir(dirname(path), { recursive: true });
     await writeFile(path, JSON.stringify(config, null, 2) + '\n', 'utf8');
 }
-export async function readTokenConfig() {
-    const path = tokenConfigPath();
-    if (!existsSync(path))
-        return {};
-    return JSON.parse(await readFile(path, 'utf8'));
-}
-export async function writeTokenConfig(config) {
-    const path = tokenConfigPath();
-    await mkdir(dirname(path), { recursive: true });
-    await writeFile(path, JSON.stringify(config, null, 2) + '\n', { encoding: 'utf8', mode: 0o600 });
-}
 /**
  * Environment map injected by the embedding CLI (seq-studio sets
  * ARTIFACT_STUDIO_ENV_URLS to the JSON name→url map of environments visible

package/dist/deployment-validation.d.ts

@@ -0,0 +1,9 @@
+export declare function validateDeploymentBaseUrl(input: string): string;
+export declare function validateDeploymentAudience({ audience, baseUrl, }: {
+    audience: string;
+    baseUrl: string;
+}): string;
+export declare function authenticatedRequestUrl({ baseUrl, path, }: {
+    baseUrl: string;
+    path: string;
+}): string;

package/dist/deployment-validation.js

@@ -0,0 +1,70 @@
+const TRUSTED_DEPLOYMENT_DOMAIN = 'seqholdings.com';
+export function validateDeploymentBaseUrl(input) {
+    if (input !== input.trim()) {
+        throw new Error(`Invalid deployment URL '${input}'.`);
+    }
+    let parsed;
+    try {
+        parsed = new URL(input);
+    }
+    catch {
+        throw new Error(`Invalid deployment URL '${input}'.`);
+    }
+    const hostname = parsed.hostname.toLowerCase();
+    const originOnly = !parsed.username &&
+        !parsed.password &&
+        (parsed.pathname === '' || parsed.pathname === '/') &&
+        !parsed.search &&
+        !parsed.hash;
+    const trustedHttps = parsed.protocol === 'https:' &&
+        (hostname === TRUSTED_DEPLOYMENT_DOMAIN ||
+            hostname.endsWith(`.${TRUSTED_DEPLOYMENT_DOMAIN}`)) &&
+        parsed.port === '';
+    const localHttp = parsed.protocol === 'http:' &&
+        ['localhost', '127.0.0.1', '[::1]'].includes(hostname);
+    if (!originOnly || (!trustedHttps && !localHttp)) {
+        throw new Error(`Untrusted deployment URL '${input}': expected an HTTPS origin under ` +
+            `*.${TRUSTED_DEPLOYMENT_DOMAIN}, or an HTTP localhost/loopback origin.`);
+    }
+    return trustedHttps ? `https://${hostname}` : parsed.origin.toLowerCase();
+}
+export function validateDeploymentAudience({ audience, baseUrl, }) {
+    const expected = `${baseUrl}/api`;
+    if (audience !== expected) {
+        throw new Error(`Untrusted Auth0 audience '${audience}': deployment ${baseUrl} must use '${expected}'.`);
+    }
+    return audience;
+}
+export function authenticatedRequestUrl({ baseUrl, path, }) {
+    const trustedOrigin = validateDeploymentBaseUrl(baseUrl);
+    if (!path.startsWith('/')) {
+        throw new Error(`Invalid authenticated request path '${path}': expected an absolute path.`);
+    }
+    if (path.startsWith('//')) {
+        throw new Error(`Invalid authenticated request path '${path}': scheme-relative paths are not allowed.`);
+    }
+    if ([...path].some((character) => character.charCodeAt(0) < 0x20)) {
+        throw new Error(`Invalid authenticated request path '${path}': control character.`);
+    }
+    const separatorIndex = path.search(/[?#]/);
+    const rawPathname = separatorIndex === -1 ? path : path.slice(0, separatorIndex);
+    const traversalCandidate = rawPathname
+        .replace(/%2e/gi, '.')
+        .replace(/%2f/gi, '/')
+        .replace(/%5c/gi, '\\');
+    if (traversalCandidate.includes('\\') ||
+        traversalCandidate.split('/').some((segment) => segment === '.' || segment === '..')) {
+        throw new Error(`Invalid authenticated request path '${path}': traversal is not allowed.`);
+    }
+    let request;
+    try {
+        request = new URL(path, `${trustedOrigin}/`);
+    }
+    catch {
+        throw new Error(`Invalid authenticated request path '${path}'.`);
+    }
+    if (request.origin.toLowerCase() !== trustedOrigin) {
+        throw new Error(`Untrusted authenticated request origin '${request.origin}': expected '${trustedOrigin}'.`);
+    }
+    return request.href;
+}

package/dist/git-clone.js

@@ -10,9 +10,10 @@
  * HTTPS clone URL plus the PAT separately.
  */
 import { spawn } from 'node:child_process';
-import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { createScrubbedChildEnv } from './child-environment.js';
 /** Read the git PAT from the environment (`ATLAS_GIT_PAT`), trimmed. */
 export function resolveGitPatFromEnv() {
     const value = process.env.ATLAS_GIT_PAT?.trim();
@@ -108,6 +109,7 @@ async function spawnGit({ args, env, cwd, timeoutMs = GIT_CLONE_TIMEOUT_MS, }) {
  */
 export async function withGitAskpass({ pat, fn, }) {
     const dir = await mkdtemp(join(tmpdir(), 'artifact-askpass-'));
+    const homeDir = join(dir, 'home');
     const scriptPath = join(dir, 'askpass.sh');
     const script = [
         '#!/bin/sh',
@@ -117,17 +119,21 @@ export async function withGitAskpass({ pat, fn, }) {
         'esac',
         '',
     ].join('\n');
+    await mkdir(homeDir, { recursive: true });
     await writeFile(scriptPath, script, { mode: 0o700 });
     try {
-        return await fn({
-            ...process.env,
-            GIT_ASKPASS: scriptPath,
-            GIT_TERMINAL_PROMPT: '0',
-            SEQ_STUDIO_GIT_ASKPASS_PASSWORD: pat,
-            GIT_CONFIG_COUNT: '1',
-            GIT_CONFIG_KEY_0: 'credential.helper',
-            GIT_CONFIG_VALUE_0: '',
-        });
+        return await fn(createScrubbedChildEnv({
+            homeDir,
+            additionalEnv: {
+                GIT_ASKPASS: scriptPath,
+                GIT_TERMINAL_PROMPT: '0',
+                GIT_CONFIG_NOSYSTEM: '1',
+                SEQ_STUDIO_GIT_ASKPASS_PASSWORD: pat,
+                GIT_CONFIG_COUNT: '1',
+                GIT_CONFIG_KEY_0: 'credential.helper',
+                GIT_CONFIG_VALUE_0: '',
+            },
+        }));
     }
     finally {
         await rm(dir, { recursive: true, force: true });

package/dist/prepare-build.d.ts

@@ -16,6 +16,8 @@ export declare function buildControlledArtifactNpmrc(userNpmrcPath?: string): st
 export interface PrepareBuildOptions {
     /** Remote sources (--repo / --git-url) install when package.json exists. */
     remote?: boolean;
+    /** Parent environment override for deterministic security tests. */
+    sourceEnv?: NodeJS.ProcessEnv;
 }
 /**
  * Whether the build should run `pnpm install` before Vite bundles the tree.

package/dist/prepare-build.js

@@ -1,8 +1,9 @@
 import { execFileSync } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
-import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { homedir, tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { createScrubbedChildEnv } from './child-environment.js';
 import { stripInstallControlFiles } from './sanitize-remote-tree.js';
 import { assertTrustedArtifactInstallTree } from './trusted-install.js';
 /**
@@ -82,10 +83,25 @@ export async function prepareArtifactBuildRoot(dir, opts = {}) {
     await rm(join(dir, 'node_modules'), { recursive: true, force: true });
     const configDir = await mkdtemp(join(tmpdir(), 'artifact-pnpm-'));
     const controlledNpmrc = join(configDir, '.npmrc');
-    const args = ['install', '--frozen-lockfile', '--ignore-scripts', '--prod'];
-    const userNpmrcPath = process.env.npm_config_userconfig ?? join(homedir(), '.npmrc');
+    const homeDir = join(configDir, 'home');
+    // Caches are deliberately scoped to one install. The untrusted package
+    // manager subprocess runs as the caller's uid, so a persistent cache would
+    // let one source poison dependencies consumed by a later build.
+    const npmCache = join(configDir, 'npm-cache');
+    const pnpmStore = join(configDir, 'pnpm-store');
+    const args = [
+        'install',
+        '--frozen-lockfile',
+        '--ignore-scripts',
+        '--prod',
+        '--store-dir',
+        pnpmStore,
+    ];
+    const sourceEnv = opts.sourceEnv ?? process.env;
+    const userNpmrcPath = sourceEnv.npm_config_userconfig ?? join(homedir(), '.npmrc');
     console.log(`[seq-studio] installing dependencies (frozen lockfile, prod only) via ${ARTIFACT_BUILD_PNPM}…`);
     try {
+        await mkdir(homeDir, { recursive: true });
         await writeFile(controlledNpmrc, buildControlledArtifactNpmrc(userNpmrcPath), { mode: 0o600 });
         // Run a PINNED pnpm via `npx`, not the operator's ambient `pnpm`. The
         // install must be reproducible across laptops and CI: in a bare temp clone
@@ -101,10 +117,14 @@ export async function prepareArtifactBuildRoot(dir, opts = {}) {
         execFileSync('npx', ['--yes', ARTIFACT_BUILD_PNPM, '--dir', dir, ...args], {
             cwd: configDir,
             stdio: 'inherit',
-            env: {
-                ...process.env,
-                npm_config_userconfig: controlledNpmrc,
-            },
+            env: createScrubbedChildEnv({
+                homeDir,
+                source: sourceEnv,
+                additionalEnv: {
+                    npm_config_userconfig: controlledNpmrc,
+                    npm_config_cache: npmCache,
+                },
+            }),
         });
     }
     catch (error) {

package/dist/sdk.d.ts

@@ -8,8 +8,12 @@ export interface SequenceApiFetchResponse<TBody = unknown> {
     status: number;
     body: TBody;
 }
+export interface SequenceApiUploadOptions {
+    timeoutMs?: number;
+}
 export interface SequenceApi {
     fetch<TBody = unknown>(path: string, options?: SequenceApiFetchOptions): Promise<SequenceApiFetchResponse<TBody>>;
+    upload<TBody = unknown>(path: string, file: File, fields?: Record<string, string>, options?: SequenceApiUploadOptions): Promise<SequenceApiFetchResponse<TBody>>;
     stream(path: string, options?: SequenceApiFetchOptions): Promise<ReadableStream<Uint8Array>>;
     get<TBody = unknown>(path: string): Promise<TBody>;
     post<TBody = unknown>(path: string, body?: unknown): Promise<TBody>;

package/dist/source-resolver.d.ts

@@ -37,6 +37,7 @@ export interface ResolvedSource {
     /** Remove any temp materialization. No-op for a local source. Never throws. */
     cleanup: () => Promise<void>;
 }
+export type SourceAuthMode = 'm2m' | 'user';
 export interface ParsedFlags {
     positional: string[];
     flags: Record<string, string | true>;
@@ -44,9 +45,9 @@ export interface ParsedFlags {
 /** True for sources that must be fetched from a remote (git-service / git-url). */
 export declare function isRemoteSpec(spec: SourceSpec): boolean;
 /**
- * Strip any userinfo (`user:token@`) from a git URL before it's logged or put
- * in an error — an https git URL can carry a PAT in its authority, and leaking
- * it to a terminal or CI log is a credential disclosure.
+ * Strip every URL component that can carry credentials before a git URL is
+ * logged or put in an error. Unparseable input is fully withheld because its
+ * structure cannot be inspected safely.
  */
 export declare function redactGitUrl(url: string): string;
 /**
@@ -57,10 +58,12 @@ export declare function redactGitUrl(url: string): string;
 export declare function parseSourceSpec(input: ParsedFlags): SourceSpec;
 /**
  * Resolve a spec to an on-disk source directory + provenance. For git-service
- * the caller must supply `baseUrl` + `token`; git-url needs neither (it shells
- * out to `git clone`); local needs nothing.
+ * the caller must supply `baseUrl` + `token` and the resolved auth mode;
+ * git-url needs no token but rejects a selected M2M principal (it shells out
+ * to `git clone`); local needs nothing.
  */
 export declare function resolveArtifactSource(spec: SourceSpec, opts?: {
+    authMode?: SourceAuthMode;
     baseUrl?: string;
     token?: string | null;
 }): Promise<ResolvedSource>;

package/dist/source-resolver.js

@@ -3,6 +3,7 @@ import { mkdirSync, rmSync } from 'node:fs';
 import { mkdtemp, realpath, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join, resolve } from 'node:path';
+import { createScrubbedChildEnv } from './child-environment.js';
 import { materializeRepo, resolveCommitSha, resolveRepo } from './git-service-client.js';
 import { gitServiceCloneUrl, resolveGitPatFromEnv, runGitClone } from './git-clone.js';
 /** True for sources that must be fetched from a remote (git-service / git-url). */
@@ -10,23 +11,23 @@ export function isRemoteSpec(spec) {
     return spec.kind !== 'local';
 }
 /**
- * Strip any userinfo (`user:token@`) from a git URL before it's logged or put
- * in an error — an https git URL can carry a PAT in its authority, and leaking
- * it to a terminal or CI log is a credential disclosure.
+ * Strip every URL component that can carry credentials before a git URL is
+ * logged or put in an error. Unparseable input is fully withheld because its
+ * structure cannot be inspected safely.
  */
 export function redactGitUrl(url) {
     try {
         const parsed = new URL(url);
-        if (parsed.username || parsed.password) {
-            parsed.username = '';
-            parsed.password = '';
-            return parsed.toString();
-        }
-        return url;
+        if (!parsed.username && !parsed.password && !parsed.search && !parsed.hash)
+            return url;
+        parsed.username = '';
+        parsed.password = '';
+        parsed.search = '';
+        parsed.hash = '';
+        return parsed.toString();
     }
     catch {
-        // Non-standard form (e.g. scp-like git@host:path) — drop a scheme://user@ prefix if present.
-        return url.replace(/^([a-z][a-z0-9+.-]*:\/\/)[^/@]*@/i, '$1');
+        return '<redacted-invalid-git-url>';
     }
 }
 function flagString(flags, key) {
@@ -61,27 +62,43 @@ export function parseSourceSpec(input) {
         return { kind: 'git-service', namespace: parts[0], name: parts[1], ref };
     }
     if (gitUrl) {
-        // Guard against argument injection: git treats a leading-dash URL as a flag.
-        if (gitUrl.startsWith('-'))
-            throw new Error(`--git-url must be a URL, not a flag (got "${gitUrl}").`);
+        let parsed;
+        try {
+            parsed = new URL(gitUrl);
+        }
+        catch {
+            throw new Error(`--git-url must be a credential-free HTTPS URL (got "${redactGitUrl(gitUrl)}").`);
+        }
+        if (parsed.protocol !== 'https:' ||
+            parsed.username ||
+            parsed.password ||
+            parsed.search ||
+            parsed.hash) {
+            throw new Error(`--git-url must be a credential-free HTTPS URL (got "${redactGitUrl(gitUrl)}").`);
+        }
         return { kind: 'git-url', url: gitUrl, ref };
     }
     return { kind: 'local', dir: resolve(dir ?? '.') };
 }
 /**
  * Resolve a spec to an on-disk source directory + provenance. For git-service
- * the caller must supply `baseUrl` + `token`; git-url needs neither (it shells
- * out to `git clone`); local needs nothing.
+ * the caller must supply `baseUrl` + `token` and the resolved auth mode;
+ * git-url needs no token but rejects a selected M2M principal (it shells out
+ * to `git clone`); local needs nothing.
  */
 export async function resolveArtifactSource(spec, opts = {}) {
     if (spec.kind === 'local') {
         return { dir: spec.dir, remote: false, provenance: localGitMetadata(spec.dir), cleanup: async () => { } };
     }
-    const dest = await makeTempDir();
-    const cleanup = () => removeDir(dest);
+    if (spec.kind === 'git-url' && opts.authMode === 'm2m') {
+        throw new Error('M2M/CI builds only accept platform-managed --repo sources; arbitrary --git-url sources are not trusted in CI.');
+    }
+    const workspace = await makeTempDir();
+    const dest = join(workspace, 'source');
+    const cleanup = () => removeDir(workspace);
     try {
         if (spec.kind === 'git-service') {
-            if (!opts.baseUrl || !opts.token) {
+            if (!opts.authMode || !opts.baseUrl || !opts.token) {
                 throw new Error('Deploying from --repo needs a target environment and auth. ' +
                     'Pass --env and run `seq-studio login`.');
             }
@@ -92,6 +109,16 @@ export async function resolveArtifactSource(spec, opts = {}) {
             const repo = await resolveRepo({ baseUrl: opts.baseUrl, token: opts.token, namespace: spec.namespace, name: spec.name });
             const ref = spec.ref ?? repo.defaultBranch;
             const sha = await resolveCommitSha({ baseUrl: opts.baseUrl, token: opts.token, repoId: repo.id, ref });
+            // CI/system path: the trusted M2M service account can't own a PAT (PAT
+            // issuance is gated on a human Auth0 user row), so it keeps the JSON
+            // materialize path it has always used, authenticated by its M2M token.
+            // Ignore any unrelated human PAT inherited by the parent shell: the
+            // selected principal determines both transport and audit identity.
+            if (opts.authMode === 'm2m') {
+                const count = await materializeRepo({ baseUrl: opts.baseUrl, token: opts.token, repoId: repo.id, ref: sha, destDir: dest });
+                console.log(`[seq-studio] source: ${spec.namespace}/${spec.name}@${ref} (${sha.slice(0, 10)}, ${count} file(s), M2M)`);
+                return { dir: dest, remote: true, provenance: { gitCommit: sha, gitBranch: ref, gitDirty: false }, cleanup };
+            }
             // Human path: materialize via a smart-HTTP `git clone` (one pack
             // transfer). The earlier per-blob JSON walk was O(files) serial HTTP
             // round-trips and stalled/failed on large artifacts. Smart-HTTP
@@ -104,17 +131,6 @@ export async function resolveArtifactSource(spec, opts = {}) {
                 console.log(`[seq-studio] source: ${spec.namespace}/${spec.name}@${ref} (${sha.slice(0, 10)}, git clone)`);
                 return { dir: dest, remote: true, provenance: { gitCommit: sha, gitBranch: ref, gitDirty: false }, cleanup };
             }
-            // CI/system path: the trusted M2M service account can't own a PAT (PAT
-            // issuance is gated on a human Auth0 user row), so it keeps the JSON
-            // materialize path it has always used, authenticated by its M2M token.
-            // Interactive callers (no PAT, no M2M) fall through to the hard error.
-            // TODO: teach the git-service smart-HTTP endpoint to accept the trusted
-            // M2M identity so CI can use the fast clone path too.
-            if (process.env.AUTH0_M2M_CLIENT_SECRET?.trim()) {
-                const count = await materializeRepo({ baseUrl: opts.baseUrl, token: opts.token, repoId: repo.id, ref: sha, destDir: dest });
-                console.log(`[seq-studio] source: ${spec.namespace}/${spec.name}@${ref} (${sha.slice(0, 10)}, ${count} file(s), M2M)`);
-                return { dir: dest, remote: true, provenance: { gitCommit: sha, gitBranch: ref, gitDirty: false }, cleanup };
-            }
             throw new Error('Deploying from --repo requires a git PAT. Set ATLAS_GIT_PAT to a token with the ' +
                 'repo:read scope (create one in Atlas → Settings → Tokens, or `seq-studio auth pat create`). ' +
                 'The git-service clone uses smart-HTTP, which authenticates by PAT — the same token you clone the repo with.');
@@ -163,9 +179,18 @@ async function removeDir(dir) {
     }
 }
 function cloneGitUrl(url, ref, dest) {
+    const homeDir = join(resolve(dest, '..'), 'home');
+    mkdirSync(homeDir, { recursive: true });
     const opts = {
         stdio: ['ignore', 'pipe', 'pipe'],
         encoding: 'utf8',
+        env: createScrubbedChildEnv({
+            homeDir,
+            additionalEnv: {
+                GIT_CONFIG_NOSYSTEM: '1',
+                GIT_TERMINAL_PROMPT: '0',
+            },
+        }),
     };
     const git = (args) => String(execFileSync('git', args, opts)).trim();
     try {

package/dist/templates/react-vite/CLAUDE.md

@@ -41,7 +41,7 @@ Use **pnpm** for artifacts you will deploy from git — `seq-studio artifact bui
 
 ## Defaults
 
-- UI: prefer `@sequenceholdings/atlas-ui` primitives (`Button`, `Card`, `Input`, `Dialog`, `Select`, `Checkbox`, `DropdownMenu`, `KpiTile`, `Switch`, …) over raw Tailwind. The design-system cutover made `Select`, `Checkbox`, `DropdownMenu`, `Command`, `Calendar`, `DatePicker`, `ScrollArea`, `Table`, and the Task family first-class exports — use them directly; fall back to `Popover` compositions or native controls only when a component is genuinely missing.
+- UI: prefer `@sequenceholdings/atlas-ui` primitives (`Button`, `Card`, `Input`, `Dialog`, `Select`, `Checkbox`, `DropdownMenu`, `KpiTile`, `Switch`, …) over raw Tailwind. The design-system cutover made `Select`, `Checkbox`, `DropdownMenu`, `Command`, `Calendar`, `ScrollArea`, `Table`, and the Task family first-class exports — use them directly; fall back to `Popover` compositions or native controls only when a component is genuinely missing.
 - Routing: `HashRouter`. Mount routes at `/`, not at the Atlas app prefix.
 - Data: React Query is wired in `src/main.tsx`. Use `useQuery` / `useMutation` against `unwrap(seq.api.*)`.
 - Icons: do **not** add third-party deps like `@tabler/icons-react`. Deploys from git (`--repo` / `--git-url`) build a bare tree — `seq-studio` runs `pnpm install --prod` from your lockfile, then aliases platform peers (`react`, `react-dom`, `@tanstack/react-query`, `react-router-dom`, `sonner`, `@sequenceholdings/atlas-ui`). List only app-specific imports (e.g. `recharts`) in `dependencies`; do not add file/workspace `@sequenceholdings/*` specs in git-service repos, because remote installs only accept registry semver specs. Inline SVG components in `src/icons.tsx`.

package/dist/templates/react-vite/src/styles.css

@@ -1,3 +1,11 @@
 @import "tailwindcss";
 @import "tw-animate-css";
 @import "@sequenceholdings/atlas-ui/tokens.css";
+
+/* Tailwind v4 skips node_modules during automatic source detection, so the
+   utility classes compiled into atlas-ui's components are never generated under
+   raw `pnpm dev`. The deploy build auto-injects this @source (build.ts's
+   atlasUiCssResolverPlugin), but plain Vite dev does not — declare it here so
+   scaffolded artifacts render atlas-ui correctly in local dev too. Idempotent
+   with the build-time injection. */
+@source "../node_modules/@sequenceholdings/atlas-ui/dist";

package/package.json

@@ -9,7 +9,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.1.11",
+  "version": "0.1.15",
   "description": "SDK types and CLI library for building Artifact Studio apps. Driven via `seq-studio artifact <sub>` (@sequenceholdings/studio-cli), which runs the `./cli` runCli export.",
   "type": "module",
   "exports": {
@@ -32,6 +32,30 @@
     "./git-clone": {
       "types": "./dist/git-clone.d.ts",
       "default": "./dist/git-clone.js"
+    },
+    "./prepare-build": {
+      "types": "./dist/prepare-build.d.ts",
+      "default": "./dist/prepare-build.js"
+    },
+    "./sanitize-remote-tree": {
+      "types": "./dist/sanitize-remote-tree.d.ts",
+      "default": "./dist/sanitize-remote-tree.js"
+    },
+    "./lockfile-origin": {
+      "types": "./dist/lockfile-origin.d.ts",
+      "default": "./dist/lockfile-origin.js"
+    },
+    "./trusted-install": {
+      "types": "./dist/trusted-install.d.ts",
+      "default": "./dist/trusted-install.js"
+    },
+    "./deployment-validation": {
+      "types": "./dist/deployment-validation.d.ts",
+      "default": "./dist/deployment-validation.js"
+    },
+    "./child-environment": {
+      "types": "./dist/child-environment.d.ts",
+      "default": "./dist/child-environment.js"
     }
   },
   "files": [
@@ -61,7 +85,7 @@
     "vitest": "^4.1.2"
   },
   "scripts": {
-    "build": "tsc && node scripts/copy-templates.mjs",
+    "build": "rm -rf dist && tsc && node scripts/copy-templates.mjs",
     "type-check": "tsc --noEmit",
     "test": "vitest run",
     "bench:build-isolation": "node --expose-gc scripts/bench-build-isolation.mjs"

package/templates/react-vite/CLAUDE.md

@@ -41,7 +41,7 @@ Use **pnpm** for artifacts you will deploy from git — `seq-studio artifact bui
 
 ## Defaults
 
-- UI: prefer `@sequenceholdings/atlas-ui` primitives (`Button`, `Card`, `Input`, `Dialog`, `Select`, `Checkbox`, `DropdownMenu`, `KpiTile`, `Switch`, …) over raw Tailwind. The design-system cutover made `Select`, `Checkbox`, `DropdownMenu`, `Command`, `Calendar`, `DatePicker`, `ScrollArea`, `Table`, and the Task family first-class exports — use them directly; fall back to `Popover` compositions or native controls only when a component is genuinely missing.
+- UI: prefer `@sequenceholdings/atlas-ui` primitives (`Button`, `Card`, `Input`, `Dialog`, `Select`, `Checkbox`, `DropdownMenu`, `KpiTile`, `Switch`, …) over raw Tailwind. The design-system cutover made `Select`, `Checkbox`, `DropdownMenu`, `Command`, `Calendar`, `ScrollArea`, `Table`, and the Task family first-class exports — use them directly; fall back to `Popover` compositions or native controls only when a component is genuinely missing.
 - Routing: `HashRouter`. Mount routes at `/`, not at the Atlas app prefix.
 - Data: React Query is wired in `src/main.tsx`. Use `useQuery` / `useMutation` against `unwrap(seq.api.*)`.
 - Icons: do **not** add third-party deps like `@tabler/icons-react`. Deploys from git (`--repo` / `--git-url`) build a bare tree — `seq-studio` runs `pnpm install --prod` from your lockfile, then aliases platform peers (`react`, `react-dom`, `@tanstack/react-query`, `react-router-dom`, `sonner`, `@sequenceholdings/atlas-ui`). List only app-specific imports (e.g. `recharts`) in `dependencies`; do not add file/workspace `@sequenceholdings/*` specs in git-service repos, because remote installs only accept registry semver specs. Inline SVG components in `src/icons.tsx`.

package/templates/react-vite/src/styles.css

@@ -1,3 +1,11 @@
 @import "tailwindcss";
 @import "tw-animate-css";
 @import "@sequenceholdings/atlas-ui/tokens.css";
+
+/* Tailwind v4 skips node_modules during automatic source detection, so the
+   utility classes compiled into atlas-ui's components are never generated under
+   raw `pnpm dev`. The deploy build auto-injects this @source (build.ts's
+   atlasUiCssResolverPlugin), but plain Vite dev does not — declare it here so
+   scaffolded artifacts render atlas-ui correctly in local dev too. Idempotent
+   with the build-time injection. */
+@source "../node_modules/@sequenceholdings/atlas-ui/dist";

package/dist/auth.d.ts

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

package/dist/auth.js

@@ -1,129 +0,0 @@
-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 seq-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);
-        });
-    });
-}