statelyai 0.4.1 → 0.5.1

package/README.md

@@ -26,6 +26,8 @@ statelyai init
 statelyai init --scan
 ```
 
+If you have an older `statelyai.json` that still uses the legacy `sources` shape, the CLI will rewrite simple single-source configs automatically when it reads them.
+
 That writes a `statelyai.json` like:
 
 ```json
@@ -36,7 +38,8 @@ That writes a `statelyai.json` like:
   "studioUrl": "https://stately.ai",
   "defaultXStateVersion": 5,
   "include": ["src/**/*.ts"],
-  "exclude": ["**/*.test.*", "**/*.spec.*"]
+  "exclude": ["**/*.test.*", "**/*.spec.*"],
+  "newMachinesDir": "src"
 }
 ```
 
@@ -54,13 +57,13 @@ statelyai push --dry-run
 
 If a saved `// @statelyai id=...` points to a deleted or inaccessible remote machine, `push` will prompt to relink the file as a new remote machine and replace the local id.
 
-6. Pull remote changes back into linked local files:
+6. Pull remote changes back into linked local files and create new local files for remote-only project machines when `newMachinesDir` is configured:
 
 ```bash
 statelyai pull
 ```
 
-`pull` skips locally modified files unless you pass `--force`.
+`pull` skips locally modified linked files unless you pass `--force`. New remote-only machines are written as `<machine-name>.machine.ts` inside `newMachinesDir`.
 
 Run it without installing it globally:
 

package/dist/bin.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { u as run } from "./cli-DkWxDq0T.mjs";
+import { p as run } from "./cli-D4Id6WsS.mjs";
 
 //#region src/bin.ts
 run();

package/dist/{cli-DkWxDq0T.mjs → cli-D4Id6WsS.mjs}

@@ -975,17 +975,45 @@ function normalizeProjectConfig(config) {
 		studioUrl: config.studioUrl ?? "https://stately.ai",
 		defaultXStateVersion: Math.max(5, config.defaultXStateVersion ?? 5),
 		include: [...config.include ?? firstSource?.include ?? []],
-		exclude: config.exclude == null ? [...firstSource?.exclude ?? DEFAULT_SOURCE_EXCLUDES] : [...config.exclude]
+		exclude: config.exclude == null ? [...firstSource?.exclude ?? DEFAULT_SOURCE_EXCLUDES] : [...config.exclude],
+		...config.newMachinesDir ? { newMachinesDir: config.newMachinesDir } : {}
+	};
+}
+function getConfigRewriteStatus(config) {
+	if (!config.sources) return { needsRewrite: false };
+	if (config.sources.length > 1) return {
+		needsRewrite: true,
+		reason: "multiple-legacy-sources"
+	};
+	return {
+		needsRewrite: true,
+		reason: "legacy-sources"
 	};
 }
 async function readStatelyProjectConfig(options = {}) {
 	const rootDir = path.resolve(options.cwd ?? process.cwd());
 	const configPath = path.resolve(rootDir, options.configPath ?? STATELY_CONFIG_FILE);
 	const raw = await fsPromises.readFile(configPath, "utf8");
+	const parsed = JSON.parse(raw);
+	const config = normalizeProjectConfig(parsed);
+	const rewriteStatus = getConfigRewriteStatus(parsed);
+	if (options.rewriteIfNeeded && rewriteStatus.reason === "legacy-sources") {
+		await fsPromises.writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+		return {
+			config,
+			configPath,
+			rootDir,
+			rewriteStatus: {
+				needsRewrite: false,
+				rewritten: true
+			}
+		};
+	}
 	return {
-		config: normalizeProjectConfig(JSON.parse(raw)),
+		config,
 		configPath,
-		rootDir
+		rootDir,
+		rewriteStatus
 	};
 }
 async function walkFiles(rootDir, currentDir = rootDir) {
@@ -1060,6 +1088,9 @@ function matchesGlob(relativePath, pattern) {
 function matchesAny(patterns, relativePath) {
 	return (patterns ?? []).some((pattern) => matchesGlob(relativePath, pattern));
 }
+function isTrackedByStatelyProjectConfig(config, relativePath) {
+	return matchesAny(config.include, relativePath) && !matchesAny(config.exclude ?? DEFAULT_SOURCE_EXCLUDES, relativePath);
+}
 async function discoverCodeSourceFiles(options = {}) {
 	const rootDir = path.resolve(options.cwd ?? process.cwd());
 	return (await filterGitIgnoredPaths(rootDir, await walkFiles(rootDir))).filter((relativePath) => isCodeSourceFile(relativePath)).filter((relativePath) => !matchesAny(DEFAULT_SOURCE_EXCLUDES, relativePath)).sort((left, right) => left.localeCompare(right));
@@ -1157,6 +1188,13 @@ async function discoverStatelySourceFiles(options = {}) {
 //#region src/cli.ts
 const execFileAsync = promisify(execFile);
 const STATELY_API_KEY_SETTINGS_URL = "https://stately.ai/registry/user/my-settings?tab=API+Key";
+const DEFAULT_NEW_MACHINE_FILE_SUFFIX = ".machine.ts";
+const ANSI_RESET = "\x1B[0m";
+const ANSI_BOLD = "\x1B[1m";
+const ANSI_DIM = "\x1B[2m";
+const ANSI_CYAN = "\x1B[36m";
+const ANSI_GREEN = "\x1B[32m";
+const ANSI_YELLOW = "\x1B[33m";
 function loadLocalEnv() {
 	if (typeof process.loadEnvFile !== "function") return;
 	const cwdEnvPath = path.join(process.cwd(), ".env.local");
@@ -1310,6 +1348,43 @@ function normalizeApiKey(value) {
 function pluralize(count, singular, plural = `${singular}s`) {
 	return count === 1 ? singular : plural;
 }
+function supportsColor() {
+	return Boolean(process.stdout.isTTY) && process.env.NO_COLOR == null && process.env.CI !== "true";
+}
+function colorize(text, ...codes) {
+	if (!supportsColor()) return text;
+	return `${codes.join("")}${text}${ANSI_RESET}`;
+}
+function formatSectionLabel(label, tone = "info") {
+	return colorize(label, ANSI_BOLD, tone === "success" ? ANSI_GREEN : tone === "warning" ? ANSI_YELLOW : ANSI_CYAN);
+}
+function formatSecondaryText(text) {
+	return colorize(text, ANSI_DIM);
+}
+function inferSuggestedNewMachineDir(config) {
+	const include = config.include[0];
+	if (!include) return "src";
+	const groupedRootMatch = include.match(/^(src|packages\/[^/]+\/src|apps\/[^/]+\/src)(?:\/|$)/);
+	if (groupedRootMatch?.[1]) return groupedRootMatch[1];
+	const globIndex = include.indexOf("**/");
+	if (globIndex > 0) return include.slice(0, globIndex).replace(/\/$/, "") || "src";
+	const wildcardIndex = include.indexOf("*");
+	if (wildcardIndex > 0) return path.posix.dirname(include.slice(0, wildcardIndex)) || "src";
+	return path.posix.dirname(include) === "." ? "src" : path.posix.dirname(include);
+}
+function formatMissingNewMachineDirMessage(options) {
+	const suggestedDir = inferSuggestedNewMachineDir(options.config);
+	const countLabel = pluralize(options.remoteMachineCount, "remote-only project machine");
+	return [
+		`Found ${options.remoteMachineCount} ${countLabel}, but statelyai.json does not set newMachinesDir, so they will be skipped.`,
+		"To import new machines created in Studio, add this to statelyai.json:",
+		`  "newMachinesDir": "${suggestedDir}"`,
+		"Then run `statelyai pull` again."
+	].join("\n");
+}
+function toMachineFileStem(machineName) {
+	return (typeof machineName === "string" ? machineName : "").trim().replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[^A-Za-z0-9]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase() || "machine";
+}
 function getMissingApiKeyMessage() {
 	return `No API key configured. Use \`statelyai login\`, set \`STATELY_API_KEY\`, or pass \`--api-key\`.\nGet or create an API key at ${STATELY_API_KEY_SETTINGS_URL}`;
 }
@@ -1321,6 +1396,15 @@ function buildMachineEditorUrl(studioUrl, projectId, machineId) {
 	url.searchParams.set("machineId", machineId);
 	return url.toString();
 }
+function inferNewMachineDirFromSuggestions(suggestions) {
+	if (suggestions.length !== 1) return;
+	const include = suggestions[0]?.include[0];
+	if (!include) return;
+	const globIndex = include.indexOf("**/");
+	if (globIndex >= 0) return include.slice(0, globIndex).replace(/\/$/, "") || void 0;
+	const directory = path.posix.dirname(include);
+	return directory === "." ? void 0 : directory;
+}
 function isRelinkableLinkedMachineError(error) {
 	return error instanceof StudioApiError && (error.status === 403 || error.status === 404);
 }
@@ -1400,6 +1484,46 @@ async function discoverLinkedPullTargets(files) {
 	}
 	return linkedTargets;
 }
+async function discoverRemoteProjectMachineTargets(options) {
+	const newMachineDir = options.config.newMachinesDir?.trim();
+	if (!newMachineDir) return [];
+	const targets = [];
+	const reservedRelativePaths = /* @__PURE__ */ new Set();
+	for (const machine of options.project.machines) {
+		const candidate = machine;
+		const machineId = typeof candidate.machineId === "string" ? candidate.machineId : typeof candidate.id === "string" ? candidate.id : void 0;
+		if (!machineId || options.linkedMachineIds.has(machineId)) continue;
+		const baseDirectory = path.join(options.rootDir, newMachineDir);
+		let machineName = typeof candidate.name === "string" && candidate.name.trim().length > 0 ? candidate.name : typeof candidate.key === "string" && candidate.key.trim().length > 0 ? candidate.key : void 0;
+		if ((!machineName || machineName === machineId) && options.client?.machines?.get) try {
+			const remoteMachine = await options.client.machines.get(machineId);
+			const fetchedName = typeof remoteMachine?.name === "string" && remoteMachine.name.trim().length > 0 ? remoteMachine.name : void 0;
+			if (fetchedName) machineName = fetchedName;
+		} catch {}
+		machineName ??= machineId;
+		const stem = toMachineFileStem(machineName);
+		let candidateFileName = `${stem}${DEFAULT_NEW_MACHINE_FILE_SUFFIX}`;
+		let attempt = 2;
+		for (;;) {
+			const filePath = path.join(baseDirectory, candidateFileName);
+			const relativePath = path.relative(options.rootDir, filePath).replace(/\\/g, "/");
+			if (!isTrackedByStatelyProjectConfig(options.config, relativePath)) throw new Error(`Generated path ${relativePath} for remote machine ${machineName} is not covered by include/exclude globs.`);
+			if (!reservedRelativePaths.has(relativePath) && !await fileExists(filePath)) {
+				reservedRelativePaths.add(relativePath);
+				targets.push({
+					machineId,
+					machineName,
+					filePath,
+					relativePath
+				});
+				break;
+			}
+			candidateFileName = `${stem}-${attempt}${DEFAULT_NEW_MACHINE_FILE_SUFFIX}`;
+			attempt += 1;
+		}
+	}
+	return targets;
+}
 async function initProject(options) {
 	const cwd = path.resolve(options.cwd ?? process.cwd());
 	const studioUrl = getResolvedStudioUrl(options.baseUrl);
@@ -1407,7 +1531,8 @@ async function initProject(options) {
 	const defaultXStateVersion = Math.max(5, options.defaultXStateVersion ?? 5);
 	const existingConfig = !options.force ? await readStatelyProjectConfig({
 		cwd,
-		configPath: options.configPath
+		configPath: options.configPath,
+		rewriteIfNeeded: true
 	}).catch(() => void 0) : void 0;
 	const client = options.client ?? createStatelyClient({
 		apiKey: options.apiKey,
@@ -1475,9 +1600,10 @@ function supportsMachineDiscovery(file) {
 	return file.source.format === "xstate" || file.source.format === "auto";
 }
 async function resolveConfiguredProject(options) {
-	const { config, configPath, rootDir } = await readStatelyProjectConfig({
+	const { config, configPath, rootDir, rewriteStatus } = await readStatelyProjectConfig({
 		cwd: options.cwd,
-		configPath: options.configPath
+		configPath: options.configPath,
+		rewriteIfNeeded: true
 	});
 	const studioUrl = options.baseUrl ?? config.studioUrl;
 	return {
@@ -1490,7 +1616,37 @@ async function resolveConfiguredProject(options) {
 		files: await discoverStatelySourceFiles({
 			cwd: rootDir,
 			config
-		})
+		}),
+		rewriteStatus
+	};
+}
+async function resolveConfiguredPullTargets(options) {
+	const { client, files, config, configPath, rewriteStatus } = await resolveConfiguredProject(options);
+	const linkedTargets = await discoverLinkedPullTargets(files);
+	const linkedMachineIds = new Set(linkedTargets.map((linkedTarget) => linkedTarget.machineId));
+	const project = await client.projects.get(config.projectId);
+	const skipped = [];
+	let remoteOnlyTargets = [];
+	try {
+		remoteOnlyTargets = await discoverRemoteProjectMachineTargets({
+			rootDir: path.dirname(configPath),
+			config,
+			project,
+			linkedMachineIds,
+			client
+		});
+	} catch (error) {
+		skipped.push(error instanceof Error ? error.message : String(error));
+	}
+	return {
+		client,
+		config,
+		configPath,
+		linkedTargets,
+		project,
+		remoteOnlyTargets,
+		skipped,
+		rewriteStatus
 	};
 }
 const sharedFlags = {
@@ -1608,27 +1764,42 @@ var PullCommand = class PullCommand extends ParsedSyncCommand {
 		const apiKey = (await resolveApiKey(flags["api-key"])).apiKey;
 		if (!args.source) {
 			if (!apiKey) this.error(getMissingApiKeyMessage());
-			this.log("Resolving configured project and linked source files...");
-			const { files, config } = await resolveConfiguredProject({
+			this.log(colorize("Resolving configured project and linked source files...", ANSI_CYAN));
+			const { config, linkedTargets, project, remoteOnlyTargets, skipped, rewriteStatus } = await resolveConfiguredPullTargets({
 				apiKey,
 				baseUrl: flags["base-url"],
 				configPath: flags.config
 			});
-			const linkedTargets = await discoverLinkedPullTargets(files);
-			if (linkedTargets.length === 0) {
-				this.log("No linked local machine files were discovered.");
+			if (rewriteStatus.reason === "multiple-legacy-sources") this.log("Legacy statelyai.json detected with multiple sources entries. It cannot be rewritten automatically without losing information, so please update it manually.");
+			if (linkedTargets.length === 0 && remoteOnlyTargets.length === 0) {
+				if (project.machines.length > 0 && !config.newMachinesDir) {
+					this.log(formatSectionLabel("Skipped:", "warning"));
+					this.log(formatMissingNewMachineDirMessage({
+						config,
+						remoteMachineCount: project.machines.length
+					}));
+					return;
+				}
+				this.log("No linked local machine files or remote-only project machines were discovered.");
 				return;
 			}
-			this.log(`Processing ${linkedTargets.length} ${pluralize(linkedTargets.length, "linked file")}...`);
+			if (project.machines.length > linkedTargets.length && !config.newMachinesDir) {
+				this.log(formatSectionLabel("Skipped:", "warning"));
+				this.log(formatMissingNewMachineDirMessage({
+					config,
+					remoteMachineCount: project.machines.length - linkedTargets.length
+				}));
+			}
+			this.log(colorize(`Processing ${linkedTargets.length} ${pluralize(linkedTargets.length, "linked file")}${remoteOnlyTargets.length > 0 ? ` and ${remoteOnlyTargets.length} ${pluralize(remoteOnlyTargets.length, "new remote machine")}` : ""}...`, ANSI_CYAN));
 			const pulled = [];
-			const skipped = [];
+			const created = [];
 			for (const linkedTarget of linkedTargets) {
 				const targetPath = linkedTarget.file.filePath;
 				if (!flags.force && await isFileGitDirty(targetPath)) {
 					skipped.push(`${linkedTarget.file.relativePath}: local git changes detected (pass --force to overwrite)`);
 					continue;
 				}
-				this.log(`Pulling ${linkedTarget.file.relativePath}...`);
+				this.log(colorize(`Pulling ${linkedTarget.file.relativePath}...`, ANSI_CYAN));
 				try {
 					const result = await pullSync({
 						source: linkedTarget.machineId,
@@ -1636,13 +1807,29 @@ var PullCommand = class PullCommand extends ParsedSyncCommand {
 						apiKey,
 						baseUrl: flags["base-url"] ?? config.studioUrl
 					});
-					pulled.push(`${linkedTarget.file.relativePath}: ${result.source.locator}`);
+					pulled.push(`${linkedTarget.file.relativePath}: ${formatSecondaryText(result.source.locator)}`);
 				} catch (error) {
 					skipped.push(`${linkedTarget.file.relativePath}: ${error instanceof Error ? error.message : String(error)}`);
 				}
 			}
-			if (pulled.length > 0) this.log(`Pulled:\n${pulled.join("\n")}`);
-			if (skipped.length > 0) this.log(`Skipped:\n${skipped.join("\n")}`);
+			for (const remoteTarget of remoteOnlyTargets) {
+				this.log(colorize(`Pulling new remote machine ${remoteTarget.machineName} into ${remoteTarget.relativePath}...`, ANSI_CYAN));
+				try {
+					await fsPromises.mkdir(path.dirname(remoteTarget.filePath), { recursive: true });
+					const result = await pullSync({
+						source: remoteTarget.machineId,
+						target: remoteTarget.filePath,
+						apiKey,
+						baseUrl: flags["base-url"] ?? config.studioUrl
+					});
+					created.push(`${remoteTarget.relativePath}: ${formatSecondaryText(result.source.locator)}`);
+				} catch (error) {
+					skipped.push(`${remoteTarget.relativePath}: ${error instanceof Error ? error.message : String(error)}`);
+				}
+			}
+			if (pulled.length > 0) this.log(`${formatSectionLabel("Pulled:", "success")}\n${pulled.join("\n")}`);
+			if (created.length > 0) this.log(`${formatSectionLabel("Created:", "success")}\n${created.join("\n")}`);
+			if (skipped.length > 0) this.log(`${formatSectionLabel("Skipped:", "warning")}\n${skipped.join("\n")}`);
 			return;
 		}
 		const localCandidate = path.resolve(process.cwd(), args.source);
@@ -1657,14 +1844,14 @@ var PullCommand = class PullCommand extends ParsedSyncCommand {
 		if (!target) this.error("Missing target path. Pass `statelyai pull <machine-id|url> <file>` or `statelyai pull <linked-file>`.");
 		if (!apiKey) this.error(getMissingApiKeyMessage());
 		if (!flags.force && await fileExists(target) && await isFileGitDirty(target)) this.error(`Refusing to overwrite locally modified file ${target}. Pass --force to overwrite it.`);
-		this.log(`Pulling ${source} into ${target}...`);
+		this.log(colorize(`Pulling ${source} into ${target}...`, ANSI_CYAN));
 		const result = await pullSync({
 			source,
 			target,
 			apiKey,
 			baseUrl: flags["base-url"] ?? getDefaultBaseUrl()
 		});
-		this.log(`Pulled: ${result.source.locator} -> ${result.outputPath}\nTarget: ${result.target.kind} (${result.target.format})`);
+		this.log(`${formatSectionLabel("Pulled:", "success")} ${formatSecondaryText(result.source.locator)} -> ${result.outputPath}\nTarget: ${result.target.kind} (${result.target.format})`);
 	}
 };
 var PushCommand = class PushCommand extends Command {
@@ -1689,22 +1876,27 @@ var PushCommand = class PushCommand extends Command {
 		const { args, flags } = await this.parse(PushCommand);
 		const resolvedApiKey = flags["dry-run"] ? { source: "missing" } : await resolveApiKey(flags["api-key"]);
 		if (!flags["dry-run"] && !resolvedApiKey.apiKey) this.error(getMissingApiKeyMessage());
-		this.log("Resolving configured project and source files...");
-		const { client, config, files } = flags["dry-run"] ? await (async () => {
-			const { config, rootDir } = await readStatelyProjectConfig({ configPath: flags.config });
+		this.log(colorize("Resolving configured project and source files...", ANSI_CYAN));
+		const { client, config, files, rewriteStatus } = flags["dry-run"] ? await (async () => {
+			const { config, rootDir, rewriteStatus } = await readStatelyProjectConfig({
+				configPath: flags.config,
+				rewriteIfNeeded: true
+			});
 			return {
 				client: void 0,
 				config,
 				files: await discoverStatelySourceFiles({
 					cwd: rootDir,
 					config
-				})
+				}),
+				rewriteStatus
 			};
 		})() : await resolveConfiguredProject({
 			apiKey: resolvedApiKey.apiKey,
 			baseUrl: flags["base-url"],
 			configPath: flags.config
 		});
+		if (rewriteStatus.reason === "multiple-legacy-sources") this.log("Legacy statelyai.json detected with multiple sources entries. It cannot be rewritten automatically without losing information, so please update it manually.");
 		const candidateFiles = args.file ? [{
 			filePath: path.resolve(args.file),
 			relativePath: path.relative(process.cwd(), path.resolve(args.file)),
@@ -1716,33 +1908,33 @@ var PushCommand = class PushCommand extends Command {
 			}
 		}] : files.filter(supportsMachineDiscovery);
 		if (candidateFiles.length === 0) {
-			this.log("No matching local machine source files were discovered.");
+			this.log(colorize("No matching local machine source files were discovered.", ANSI_YELLOW));
 			return;
 		}
 		const { machineFiles } = await classifyPushCandidates(candidateFiles);
 		if (machineFiles.length === 0) {
-			this.log(`Matched ${candidateFiles.length} ${pluralize(candidateFiles.length, "file")}, but no local machine sources were discovered.`);
+			this.log(colorize(`Matched ${candidateFiles.length} ${pluralize(candidateFiles.length, "file")}, but no local machine sources were discovered.`, ANSI_YELLOW));
 			return;
 		}
-		this.log(`Discovered ${machineFiles.length} ${pluralize(machineFiles.length, "file with a machine")} from ${candidateFiles.length} matched ${pluralize(candidateFiles.length, "file")}.`);
+		this.log(colorize(`Discovered ${machineFiles.length} ${pluralize(machineFiles.length, "file with a machine")} from ${candidateFiles.length} matched ${pluralize(candidateFiles.length, "file")}.`, ANSI_CYAN));
 		if (flags["dry-run"]) {
 			const wouldLink = [];
 			const wouldUpdate = [];
 			for (const file of machineFiles) {
 				const pragma = getStatelyPragma(await fsPromises.readFile(file.filePath, "utf8"), file.filePath);
-				if (pragma?.id) wouldUpdate.push(`${file.relativePath}: ${pragma.id}`);
+				if (pragma?.id) wouldUpdate.push(`${file.relativePath}: ${formatSecondaryText(pragma.id)}`);
 				else wouldLink.push(file.relativePath);
 			}
-			if (wouldLink.length > 0) this.log(`Would link:\n${wouldLink.join("\n")}`);
-			if (wouldUpdate.length > 0) this.log(`Would update:\n${wouldUpdate.join("\n")}`);
+			if (wouldLink.length > 0) this.log(`${formatSectionLabel("Would link:")}\n${wouldLink.join("\n")}`);
+			if (wouldUpdate.length > 0) this.log(`${formatSectionLabel("Would update:")}\n${wouldUpdate.join("\n")}`);
 			return;
 		}
-		this.log(`Processing ${machineFiles.length} ${pluralize(machineFiles.length, "source file")}...`);
+		this.log(colorize(`Processing ${machineFiles.length} ${pluralize(machineFiles.length, "source file")}...`, ANSI_CYAN));
 		const linked = [];
 		const refreshed = [];
 		const skipped = [];
 		for (const file of machineFiles) {
-			this.log(`Pushing ${file.relativePath}...`);
+			this.log(colorize(`Pushing ${file.relativePath}...`, ANSI_CYAN));
 			if (!supportsMachineDiscovery(file)) {
 				skipped.push(`${file.relativePath}: unsupported format ${file.source.format}`);
 				continue;
@@ -1767,7 +1959,7 @@ var PushCommand = class PushCommand extends Command {
 						skipped.push(`${file.relativePath}: linked remote machine is missing or inaccessible.`);
 						continue;
 					}
-					this.log(`Relinking ${file.relativePath} as a new remote machine...`);
+					this.log(colorize(`Relinking ${file.relativePath} as a new remote machine...`, ANSI_YELLOW));
 					result = await pushLocalMachineLinks({
 						source: file.filePath,
 						apiKey: resolvedApiKey.apiKey,
@@ -1779,13 +1971,13 @@ var PushCommand = class PushCommand extends Command {
 					});
 				} else throw error;
 			}
-			if (result.created.length > 0) linked.push(`${file.relativePath}: ${result.created.map(({ machineIndex, machine }) => `${machine.id} [${machineIndex}] ${buildMachineEditorUrl(config.studioUrl, config.projectId, machine.id)}`).join(", ")}`);
-			if (result.updated.length > 0) refreshed.push(`${file.relativePath}: ${result.updated.map(({ machineIndex, machine }) => `${machine.id} [${machineIndex}] ${buildMachineEditorUrl(config.studioUrl, config.projectId, machine.id)}`).join(", ")}`);
+			if (result.created.length > 0) linked.push(`${file.relativePath}: ${result.created.map(({ machineIndex, machine }) => `${formatSecondaryText(`${machine.id} [${machineIndex}]`)} ${formatSecondaryText(buildMachineEditorUrl(config.studioUrl, config.projectId, machine.id))}`).join(", ")}`);
+			if (result.updated.length > 0) refreshed.push(`${file.relativePath}: ${result.updated.map(({ machineIndex, machine }) => `${formatSecondaryText(`${machine.id} [${machineIndex}]`)} ${formatSecondaryText(buildMachineEditorUrl(config.studioUrl, config.projectId, machine.id))}`).join(", ")}`);
 			for (const entry of result.skipped) skipped.push(`${file.relativePath} [${entry.machineIndex}]: ${entry.reason}`);
 		}
-		if (linked.length > 0) this.log(`Linked:\n${linked.join("\n")}`);
-		if (refreshed.length > 0) this.log(`Updated:\n${refreshed.join("\n")}`);
-		if (skipped.length > 0) this.log(`Skipped:\n${skipped.join("\n")}`);
+		if (linked.length > 0) this.log(`${formatSectionLabel("Linked:", "success")}\n${linked.join("\n")}`);
+		if (refreshed.length > 0) this.log(`${formatSectionLabel("Updated:", "success")}\n${refreshed.join("\n")}`);
+		if (skipped.length > 0) this.log(`${formatSectionLabel("Skipped:", "warning")}\n${skipped.join("\n")}`);
 	}
 };
 var OpenCommand = class OpenCommand extends Command {
@@ -1889,13 +2081,15 @@ var InitCommand = class InitCommand extends Command {
 			this.log(initMessage);
 			this.log(`Suggested source globs:\n${suggestions.map((source) => `- ${source.include.join(", ")}`).join("\n")}`);
 			if (await promptYesNo("Save these source globs to statelyai.json?", true)) {
+				const inferredNewMachineDir = inferNewMachineDirFromSuggestions(suggestions);
 				const nextConfig = {
 					...result.config,
 					include: suggestions.flatMap((suggestion) => suggestion.include),
-					exclude: [...new Set(suggestions.flatMap((suggestion) => suggestion.exclude ?? []))]
+					exclude: [...new Set(suggestions.flatMap((suggestion) => suggestion.exclude ?? []))],
+					...inferredNewMachineDir ? { newMachinesDir: inferredNewMachineDir } : {}
 				};
 				await fsPromises.writeFile(result.configPath, `${JSON.stringify(nextConfig, null, 2)}\n`, "utf8");
-				this.log("Saved scanned source globs to statelyai.json.");
+				this.log(inferredNewMachineDir ? `Saved scanned source globs to statelyai.json.\nNew remote machines will be created under ${inferredNewMachineDir}/ by default.` : "Saved scanned source globs to statelyai.json.");
 			} else this.log("Left statelyai.json unchanged. Edit it before running statelyai push.");
 			return;
 		}
@@ -1991,4 +2185,4 @@ function isDirectExecution() {
 if (isDirectExecution()) run$1();
 
 //#endregion
-export { getEnvApiKey as a, isFileGitDirty as c, scanProjectSources as d, createStatelyProjectConfig as f, formatPlanSummary as i, resolveApiKey as l, classifyPushCandidates as n, inferInitProjectName as o, discoverLinkedPullTargets as r, initProject as s, COMMANDS as t, run$1 as u };
+export { formatMissingNewMachineDirMessage as a, inferInitProjectName as c, resolveApiKey as d, resolveConfiguredPullTargets as f, createStatelyProjectConfig as h, discoverRemoteProjectMachineTargets as i, initProject as l, scanProjectSources as m, classifyPushCandidates as n, formatPlanSummary as o, run$1 as p, discoverLinkedPullTargets as r, getEnvApiKey as s, COMMANDS as t, isFileGitDirty as u };

package/dist/index.d.mts

@@ -18,6 +18,7 @@ interface StatelyProjectConfig {
   defaultXStateVersion: number;
   include: string[];
   exclude?: string[];
+  newMachinesDir?: string;
 }
 interface DiscoveredSourceFile {
   filePath: string;
@@ -55,10 +56,29 @@ interface LinkedPullTarget {
   file: DiscoveredSourceFile;
   machineId: string;
 }
+interface RemoteProjectMachineTarget {
+  machineId: string;
+  machineName: string;
+  filePath: string;
+  relativePath: string;
+}
 interface PushCandidateClassification {
   machineFiles: DiscoveredSourceFile[];
   nonMachineFiles: DiscoveredSourceFile[];
 }
+interface ResolvedConfiguredPullTargets {
+  client: StudioClient;
+  config: StatelyProjectConfig;
+  configPath: string;
+  linkedTargets: LinkedPullTarget[];
+  project: ProjectData;
+  remoteOnlyTargets: RemoteProjectMachineTarget[];
+  skipped: string[];
+  rewriteStatus: {
+    needsRewrite: boolean;
+    reason?: string;
+  };
+}
 type ApiKeyResolution = {
   apiKey: string;
   detail: string;
@@ -74,11 +94,29 @@ declare function getEnvApiKey(): {
 } | undefined;
 declare function resolveApiKey(explicitApiKey?: string): Promise<ApiKeyResolution>;
 declare function inferInitProjectName(cwd: string, repo?: ConnectedRepo): string;
+declare function formatMissingNewMachineDirMessage(options: {
+  config: Pick<StatelyProjectConfig, 'include' | 'newMachinesDir'>;
+  remoteMachineCount: number;
+}): string;
 declare function isFileGitDirty(filePath: string): Promise<boolean>;
 declare function discoverLinkedPullTargets(files: DiscoveredSourceFile[]): Promise<LinkedPullTarget[]>;
+declare function discoverRemoteProjectMachineTargets(options: {
+  rootDir: string;
+  config: StatelyProjectConfig;
+  project: ProjectData;
+  linkedMachineIds: Set<string>;
+  client?: Pick<StudioClient, 'machines'>;
+}): Promise<RemoteProjectMachineTarget[]>;
 declare function initProject(options: InitProjectOptions): Promise<InitProjectResult>;
 declare function scanProjectSources(options: ScanProjectSourcesOptions): Promise<Array<Pick<StatelyProjectConfig, 'include' | 'exclude'>>>;
 declare function classifyPushCandidates(files: DiscoveredSourceFile[]): Promise<PushCandidateClassification>;
+declare function resolveConfiguredPullTargets(options: {
+  cwd?: string;
+  configPath?: string;
+  apiKey: string;
+  baseUrl?: string;
+  client?: StudioClient;
+}): Promise<ResolvedConfiguredPullTargets>;
 declare function formatPlanSummary(plan: SyncPlan): string;
 declare abstract class BaseSyncCommand extends Command {
   static enableJsonFlag: boolean;
@@ -227,4 +265,4 @@ declare const COMMANDS: {
 };
 declare function run(argv?: any, entryUrl?: string): Promise<void>;
 //#endregion
-export { ApiKeyResolution, COMMANDS, InitProjectOptions, InitProjectResult, LinkedPullTarget, PushCandidateClassification, ScanProjectSourcesOptions, classifyPushCandidates, createStatelyProjectConfig, discoverLinkedPullTargets, formatPlanSummary, getEnvApiKey, inferInitProjectName, initProject, isFileGitDirty, resolveApiKey, run, scanProjectSources };
+export { ApiKeyResolution, COMMANDS, InitProjectOptions, InitProjectResult, LinkedPullTarget, PushCandidateClassification, RemoteProjectMachineTarget, ResolvedConfiguredPullTargets, ScanProjectSourcesOptions, classifyPushCandidates, createStatelyProjectConfig, discoverLinkedPullTargets, discoverRemoteProjectMachineTargets, formatMissingNewMachineDirMessage, formatPlanSummary, getEnvApiKey, inferInitProjectName, initProject, isFileGitDirty, resolveApiKey, resolveConfiguredPullTargets, run, scanProjectSources };

package/dist/index.mjs

@@ -1,3 +1,3 @@
-import { a as getEnvApiKey, c as isFileGitDirty, d as scanProjectSources, f as createStatelyProjectConfig, i as formatPlanSummary, l as resolveApiKey, n as classifyPushCandidates, o as inferInitProjectName, r as discoverLinkedPullTargets, s as initProject, t as COMMANDS, u as run } from "./cli-DkWxDq0T.mjs";
+import { a as formatMissingNewMachineDirMessage, c as inferInitProjectName, d as resolveApiKey, f as resolveConfiguredPullTargets, h as createStatelyProjectConfig, i as discoverRemoteProjectMachineTargets, l as initProject, m as scanProjectSources, n as classifyPushCandidates, o as formatPlanSummary, p as run, r as discoverLinkedPullTargets, s as getEnvApiKey, t as COMMANDS, u as isFileGitDirty } from "./cli-D4Id6WsS.mjs";
 
-export { COMMANDS, classifyPushCandidates, createStatelyProjectConfig, discoverLinkedPullTargets, formatPlanSummary, getEnvApiKey, inferInitProjectName, initProject, isFileGitDirty, resolveApiKey, run, scanProjectSources };
+export { COMMANDS, classifyPushCandidates, createStatelyProjectConfig, discoverLinkedPullTargets, discoverRemoteProjectMachineTargets, formatMissingNewMachineDirMessage, formatPlanSummary, getEnvApiKey, inferInitProjectName, initProject, isFileGitDirty, resolveApiKey, resolveConfiguredPullTargets, run, scanProjectSources };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "statelyai",
-  "version": "0.4.1",
+  "version": "0.5.1",
   "description": "Command-line tools for Stately",
   "license": "MIT",
   "type": "module",
@@ -21,7 +21,7 @@
   },
   "dependencies": {
     "@oclif/core": "^4.10.3",
-    "@statelyai/sdk": "0.9.1"
+    "@statelyai/sdk": "0.10.1"
   },
   "devDependencies": {
     "tsdown": "0.21.0-beta.2",