feat: support Slice Machine projects (#84)

* feat: add Slice Machine backward compatibility and Type Builder gate

Support Slice Machine projects by reading legacy auth format (cookies/base)
from ~/.prismic and falling back to slicemachine.config.json for repository
name resolution. Gate init and sync commands behind a Type Builder feature
flag to direct users to Slice Machine when their repository hasn't been
upgraded yet.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix: bypass Type Builder gate in tests

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix: address review feedback for auth token handling and config fallback

Fix stale token after login in init, cookie value truncation with `=` chars,
empty host string fallback using `||`, and config error propagation.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix: use env var for Type Builder gate and fix whoami test token handling

Use PRISMIC_TYPE_BUILDER_ENABLED env var instead of TEST to control
the Type Builder gate, allowing explicit testing of both enabled and
disabled states. Fix whoami Slice Machine auth test to use login
fixture for token instead of env var.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: angeloashmore

src/auth.ts

@@ -9,27 +9,44 @@ import { DEFAULT_PRISMIC_HOST, env } from "./env";
 import { exists } from "./lib/file";
 import { stringify } from "./lib/json";
 import { appendTrailingSlash } from "./lib/url";
+import { checkIsSliceMachineProject } from "./project";
 
 const AUTH_FILE_PATH = new URL(".prismic", appendTrailingSlash(pathToFileURL(homedir())));
 const LOGIN_TIMEOUT_MS = 3 * 60 * 1000; // 3 minutes
 const PREFERRED_PORT = 5555;
 const LOGIN_SOURCE = "prismic-cli";
 
-const AuthFileSchema = z.object({
+const AuthFileSchema = z.looseObject({
 	token: z.optional(z.string().check(z.minLength(1))),
 	host: z.optional(z.string().check(z.minLength(1))),
+
+	// Backward compatibility with Slice Machine's .prismic
+	base: z.optional(z.string()),
+	cookies: z.optional(z.string()),
 });
 type AuthFile = z.infer<typeof AuthFileSchema>;
 
 export async function getToken(): Promise<string | undefined> {
 	const auth = await readAuthFile();
+	const isSliceMachineProject = await checkIsSliceMachineProject();
+	if (isSliceMachineProject && auth?.cookies) {
+		for (const cookie of auth.cookies.split("; ")) {
+			if (cookie.startsWith("prismic-auth=")) return cookie.replace(/^prismic-auth=/, "");
+		}
+	}
 	return auth?.token;
 }
 
 export async function getHost(): Promise<string> {
 	if (env.PRISMIC_HOST) return env.PRISMIC_HOST;
 	const auth = await readAuthFile();
-	return auth?.host ?? DEFAULT_PRISMIC_HOST;
+	const isSliceMachineProject = await checkIsSliceMachineProject();
+	if (isSliceMachineProject && auth?.base) {
+		try {
+			return new URL(auth.base).host || DEFAULT_PRISMIC_HOST;
+		} catch {}
+	}
+	return auth?.host || DEFAULT_PRISMIC_HOST;
 }
 
 export async function refreshToken(): Promise<string | undefined> {
@@ -64,7 +81,15 @@ async function readAuthFile(): Promise<AuthFile | undefined> {
 }
 
 async function saveAuthFile(auth: AuthFile): Promise<void> {
-	await writeFile(AUTH_FILE_PATH, stringify(auth));
+	const existingAuthFile = await readAuthFile();
+	const newAuthFile: AuthFile = { ...existingAuthFile, ...auth };
+	const isSliceMachineProject = await checkIsSliceMachineProject();
+	if (isSliceMachineProject) {
+		if (newAuthFile.host) newAuthFile.base = `https://${newAuthFile.host}/`;
+		if (newAuthFile.token)
+			newAuthFile.cookies = `prismic-auth=${newAuthFile.token}; Path=/; SameSite=none; SESSION=fake_session; Path=/; SameSite=none`;
+	}
+	await writeFile(AUTH_FILE_PATH, stringify(newAuthFile));
 }
 
 export async function createLoginSession(options?: {

src/clients/repository.ts

@@ -0,0 +1,35 @@
+import * as z from "zod/mini";
+
+import { request } from "../lib/request";
+
+const RepositorySchema = z.object({
+	quotas: z.optional(
+		z.object({
+			sliceMachineEnabled: z.boolean(),
+		}),
+	),
+});
+
+export type Repository = z.infer<typeof RepositorySchema>;
+
+export async function getRepository(config: {
+	repo: string;
+	token: string | undefined;
+	host: string;
+}): Promise<Repository> {
+	const { repo, token, host } = config;
+	const url = getRepositoryServiceUrl(host);
+	url.searchParams.set("repository", repo);
+	const response = await request(url, {
+		headers: {
+			Authorization: `Bearer ${token}`,
+			repository: repo,
+		},
+		schema: RepositorySchema,
+	});
+	return response;
+}
+
+function getRepositoryServiceUrl(host: string): URL {
+	return new URL(`https://api.internal.${host}/repository/`);
+}

src/commands/init.ts

@@ -17,6 +17,7 @@ import { openBrowser } from "../lib/browser";
 import { CommandError, createCommand, type CommandConfig } from "../lib/command";
 import { installDependencies } from "../lib/packageJson";
 import { ForbiddenRequestError, UnauthorizedRequestError } from "../lib/request";
+import { checkIsTypeBuilderEnabled, TypeBuilderRequiredError } from "../project";
 import { syncCustomTypes, syncSlices } from "./sync";
 
 const config = {
@@ -69,7 +70,7 @@ export default createCommand(config, async ({ values }) => {
 	}
 
 	// Validate repo membership
-	const token = await getToken();
+	let token = await getToken();
 	const host = await getHost();
 	let profile: Profile;
 	try {
@@ -89,7 +90,7 @@ export default createCommand(config, async ({ values }) => {
 				},
 			});
 			console.info(`Logged in as ${email}`);
-			const token = await getToken();
+			token = await getToken();
 			profile = await getProfile({ token, host });
 		} else {
 			throw error;
@@ -103,6 +104,11 @@ export default createCommand(config, async ({ values }) => {
 		);
 	}
 
+	const isTypeBuilderEnabled = await checkIsTypeBuilderEnabled(repo, { token, host });
+	if (!isTypeBuilderEnabled) {
+		throw new TypeBuilderRequiredError();
+	}
+
 	const adapter = await getAdapter();
 
 	// Create prismic.config.json

src/commands/sync.ts

@@ -8,7 +8,7 @@ import { env } from "../env";
 import { createCommand, type CommandConfig } from "../lib/command";
 import { segmentTrackEnd, segmentTrackStart } from "../lib/segment";
 import { dedent } from "../lib/string";
-import { getRepositoryName } from "../project";
+import { checkIsTypeBuilderEnabled, getRepositoryName, TypeBuilderRequiredError } from "../project";
 
 // 5 seconds balances responsiveness with API load
 const POLL_INTERVAL_MS = env.TEST ? 500 : 5000;
@@ -32,6 +32,13 @@ const config = {
 export default createCommand(config, async ({ values }) => {
 	const { repo = await getRepositoryName(), watch } = values;
 
+	const token = await getToken();
+	const host = await getHost();
+	const isTypeBuilderEnabled = await checkIsTypeBuilderEnabled(repo, { token, host });
+	if (!isTypeBuilderEnabled) {
+		throw new TypeBuilderRequiredError();
+	}
+
 	const adapter = await getAdapter();
 
 	console.info(`Syncing from repository: ${repo}`);

src/config.ts

@@ -170,7 +170,7 @@ export async function deleteLegacySliceMachineConfig(): Promise<void> {
 	await rm(configPath);
 }
 
-async function findLegacySliceMachineConfigPath(): Promise<URL> {
+export async function findLegacySliceMachineConfigPath(): Promise<URL> {
 	const configPath = await findUpward(LEGACY_SLICE_MACHINE_CONFIG_FILENAME, {
 		stop: "package.json",
 	});

src/env.ts

@@ -14,6 +14,7 @@ const Env = z.object({
 	PRISMIC_SENTRY_ENVIRONMENT: z.optional(z.string()),
 	PRISMIC_SENTRY_ENABLED: z.optional(z.stringbool()),
 	PRISMIC_HOST: z.optional(z.string()),
+	PRISMIC_TYPE_BUILDER_ENABLED: z.optional(z.stringbool()),
 });
 
 export const env = z.parse(Env, {

src/index.ts

@@ -34,7 +34,8 @@ import {
 	sentrySetUser,
 	setupSentry,
 } from "./lib/sentry";
-import { safeGetRepositoryName } from "./project";
+import { dedent } from "./lib/string";
+import { safeGetRepositoryName, TypeBuilderRequiredError } from "./project";
 
 const UNTRACKED_COMMANDS = ["login", "logout", "whoami", "sync"];
 const SKIP_REFRESH_COMMANDS = ["login", "logout"];
@@ -181,6 +182,19 @@ async function main(): Promise<void> {
 			return;
 		}
 
+		if (error instanceof TypeBuilderRequiredError) {
+			console.error(dedent`
+				This command requires the Type Builder in your repository.
+
+				As of March 2026, the Type Builder is rolling out incrementally as Slice
+				Machine's replacement. Your repository may not have access yet. Continue using
+				Slice Machine until your repository can upgrade.
+
+				Learn more at https://prismic.io/docs/type-builder
+			`);
+			return;
+		}
+
 		await sentryCaptureError(error);
 		throw error;
 	}

src/lib/amplitude.ts

@@ -0,0 +1,44 @@
+import * as z from "zod/mini";
+
+import { env } from "../env";
+
+const AMPLITUDE_API_KEY = env.PROD
+	? "client-q1CoIFNVeFUqxmRSCGXVqO3vK2zQ6bDa"
+	: "client-Gx378hyvV904fpcQbJnWy7i5p4nBkMZa";
+
+const AMPLITUDE_SERVER_URL = env.PROD
+	? "https://amplitude.prismic.io/"
+	: "https://amplitude.wroom.io/";
+
+const FlagResponseSchema = z.record(z.string(), z.object({ value: z.optional(z.string()) }));
+
+export async function evaluateFlag(
+	flag: string,
+	args: {
+		userId: string;
+		groups?: Record<string, string[]>;
+	},
+): Promise<boolean> {
+	const user: Record<string, unknown> = { user_id: args.userId };
+	if (args.groups) {
+		user.groups = args.groups;
+	}
+
+	const encodedUser = btoa(JSON.stringify(user)).replace(/\+/g, "-").replace(/\//g, "_");
+
+	const url = new URL("sdk/v2/vardata?v=0", AMPLITUDE_SERVER_URL);
+	const response = await fetch(url, {
+		headers: {
+			Authorization: `Api-Key ${AMPLITUDE_API_KEY}`,
+			"X-Amp-Exp-User": encodedUser,
+		},
+	});
+
+	if (!response.ok) {
+		throw new Error(`Amplitude flag evaluation failed: ${response.status}`);
+	}
+
+	const data = z.parse(FlagResponseSchema, await response.json());
+
+	return data[flag]?.value === "on";
+}

src/project.ts

@@ -1,9 +1,15 @@
+import { getRepository } from "./clients/repository";
+import { getProfile } from "./clients/user";
 import {
 	findConfigPath,
+	findLegacySliceMachineConfigPath,
 	findSuggestedConfigPath,
 	MissingPrismicConfig,
 	readConfig,
+	readLegacySliceMachineConfig,
 } from "./config";
+import { env } from "./env";
+import { evaluateFlag } from "./lib/amplitude";
 import { exists } from "./lib/file";
 import { appendTrailingSlash } from "./lib/url";
 
@@ -31,8 +37,18 @@ export async function safeGetRepositoryName(): Promise<string | undefined> {
 }
 
 export async function getRepositoryName(): Promise<string> {
-	const config = await readConfig();
-	return config.repositoryName;
+	try {
+		const config = await readConfig();
+		return config.repositoryName;
+	} catch (error) {
+		if (error instanceof MissingPrismicConfig) {
+			try {
+				const legacySliceMachineConfig = await readLegacySliceMachineConfig();
+				return legacySliceMachineConfig.repositoryName;
+			} catch {}
+		}
+		throw error;
+	}
 }
 
 export async function getLibraries(): Promise<URL[] | undefined> {
@@ -52,3 +68,34 @@ export async function checkIsTypeScriptProject(): Promise<boolean> {
 	const isTypeScriptProject = await exists(tsconfigPath);
 	return isTypeScriptProject;
 }
+
+export async function checkIsSliceMachineProject(): Promise<boolean> {
+	try {
+		await findLegacySliceMachineConfigPath();
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+export async function checkIsTypeBuilderEnabled(
+	repo: string,
+	config: { token: string | undefined; host: string },
+): Promise<boolean> {
+	if (env.PRISMIC_TYPE_BUILDER_ENABLED !== undefined) return env.PRISMIC_TYPE_BUILDER_ENABLED;
+
+	const { token, host } = config;
+	const profile = await getProfile({ token, host });
+	const [flagEnabled, repository] = await Promise.all([
+		evaluateFlag("dev-tools-types-builder-cloud", {
+			userId: profile.shortId,
+			groups: { Repository: [repo] },
+		}),
+		getRepository({ repo, token, host }),
+	]);
+	return flagEnabled && repository.quotas?.sliceMachineEnabled === true;
+}
+
+export class TypeBuilderRequiredError extends Error {
+	name = "TypeBuilderRequired";
+}

test/init.test.ts

@@ -93,6 +93,15 @@ it("migrates slicemachine.config.json", async ({ expect, project, prismic, repo
 	await expect(access(new URL("slicemachine.config.json", project))).rejects.toThrow();
 });
 
+it("fails when Type Builder is not enabled", async ({ expect, project, prismic, repo }) => {
+	await rm(new URL("prismic.config.json", project));
+	const { exitCode, stderr } = await prismic("init", ["--repo", repo], {
+		nodeOptions: { env: { PRISMIC_TYPE_BUILDER_ENABLED: "false" } },
+	});
+	expect(exitCode).toBe(1);
+	expect(stderr).toContain("Type Builder");
+});
+
 it("installs dependencies", async ({ expect, project, prismic, repo }) => {
 	await rm(new URL("prismic.config.json", project));