@akterjs/cli 0.0.0-stage → 0.1.1

package/dist/local/environment-cli.config.mjs

@@ -0,0 +1,90 @@
+import { U as fn } from "../Effect-CKFpqbmw.mjs";
+import { x as match } from "../Option-DkxSnBhp.mjs";
+import { t as Path } from "../Path-Djdv_eF5.mjs";
+import { F as String, M as Record, pt as fromJsonString, st as encodeEffect } from "../Schema-MiKt5K1v.mjs";
+import { a as withSubcommands, f as optional, i as withDescription$1, l as String$1, m as withDescription, o as Boolean, p as withDefault, t as make } from "../Command-Dzq9KM-h.mjs";
+import { RunnerExitedError } from "../runner-exited.errors.mjs";
+import { environmentRunner } from "./environment-runner.pure.mjs";
+import { dev, dir, history, migrate, runRunner, writeRunner } from "./local-cli.config.mjs";
+// src/local/environment-cli.config.ts
+const exitedCleanly = 0;
+const jsString = encodeEffect(fromJsonString(String));
+const jsFields = encodeEffect(fromJsonString(Record(String, String)));
+const fieldOf = (key, value) => match(value, {
+	onNone: () => ({}),
+	onSome: (given) => ({ [key]: given })
+});
+const runOperation = fn("runOperation")(function* runOperation(operation, fields, run) {
+	const path = yield* Path;
+	const directory = yield* jsString(path.resolve(run.dir));
+	const input = yield* jsFields(fields);
+	const named = yield* jsString(operation);
+	const source = environmentRunner({
+		directory,
+		input,
+		json: run.json,
+		operation: named
+	});
+	const runner = yield* writeRunner("environments.mjs", source);
+	const code = yield* runRunner([runner]);
+	if (code === exitedCleanly) return code;
+	return yield* RunnerExitedError.make({ code });
+});
+const json = Boolean("json").pipe(withDefault(false), withDescription("Print the result as JSON, in the shape Akter Cloud's operation answers"));
+const environment = String$1("environment").pipe(optional, withDescription("The environment the snapshot is of, the one promoted to serve when missing"));
+const snapshotName = String$1("name").pipe(withDescription("The snapshot's name"));
+const environmentName = String$1("name").pipe(withDescription("The environment's name"));
+const snapshotOperation = (operation, description) => make(operation, {
+	dir,
+	environment,
+	json,
+	name: snapshotName
+}, (options) => runOperation(`snapshots ${operation}`, {
+	name: options.name,
+	...fieldOf("environment", options.environment)
+}, options)).pipe(withDescription$1(description));
+const environmentOperation = (operation, description) => make(operation, {
+	dir,
+	json,
+	name: environmentName
+}, (options) => runOperation(`environments ${operation}`, { name: options.name }, options)).pipe(withDescription$1(description));
+const listSnapshots = make("list", {
+	dir,
+	environment,
+	json
+}, (options) => runOperation("snapshots list", fieldOf("environment", options.environment), options)).pipe(withDescription$1("List an environment's live snapshots"));
+const listEnvironments = make("list", {
+	dir,
+	json
+}, (options) => runOperation("environments list", {}, options)).pipe(withDescription$1("List the folder's environments, deleted ones included, and which one serves"));
+const branch = make("branch", {
+	dir,
+	from: environment,
+	json,
+	name: environmentName,
+	snapshot: String$1("snapshot").pipe(withDescription("The Ready snapshot to branch from"))
+}, (options) => runOperation("environments branch", {
+	name: options.name,
+	snapshot: options.snapshot,
+	...fieldOf("from", options.from)
+}, options)).pipe(withDescription$1("Create a quiet environment from a snapshot: it serves calls with --environment, and its timers, outbox and jobs wait until it is promoted"));
+const snapshots = make("snapshots").pipe(withDescription$1("Snapshot an environment of the local folder: each actor's database and the files"), withSubcommands([
+	snapshotOperation("create", "Snapshot an environment; akter dev serving it takes the snapshot, under each actor's command lock"),
+	listSnapshots,
+	snapshotOperation("get", "Show one live snapshot"),
+	snapshotOperation("delete", "Delete a snapshot: its copy is removed, and its id is never used again")
+]));
+const environments = make("environments").pipe(withDescription$1("Branch, promote and delete environments of the local folder"), withSubcommands([
+	listEnvironments,
+	environmentOperation("get", "Show one environment"),
+	branch,
+	environmentOperation("promote", "Serve this environment instead: its quiet lifts, so its jobs resume and its due timers fire; promote the old one to switch back"),
+	environmentOperation("delete", "Delete an environment that doesn't serve: its data is removed and its name stays taken")
+]));
+/** The commands on the local folder: `akter dev` with its environments and snapshots, `history` and `migrate`. */
+const localCommands = [
+	dev.pipe(withSubcommands([environments, snapshots])),
+	history,
+	migrate
+];
+export { localCommands };

package/dist/local/environment-runner.pure.mjs

@@ -0,0 +1,75 @@
+import { T as join } from "../Array-B4kuTQeW.mjs";
+// src/local/environment-runner.pure.ts
+const inputLines = [
+	"const Of = Schema.Struct({ environment: Schema.optionalKey(EnvironmentName) });",
+	"const Snapshotting = Schema.Struct({ environment: Schema.optionalKey(EnvironmentName), name: SnapshotName });",
+	"const Naming = Schema.Struct({ name: EnvironmentName });",
+	"const Branching = Schema.Struct({ from: Schema.optionalKey(EnvironmentName), name: EnvironmentName, snapshot: SnapshotName });"
+];
+const lineLines = [
+	"const iso = (time) => DateTime.formatIso(time);",
+	"const snapshotLine = (snapshot) => [",
+	"  snapshot.id, snapshot.name, snapshot.status, 'of ' + snapshot.environment,",
+	"  ...(snapshot.takenAt === undefined ? [] : ['taken ' + iso(snapshot.takenAt)]),",
+	"  ...(snapshot.sizeBytes === undefined ? [] : [snapshot.sizeBytes + ' bytes']),",
+	"  ...(snapshot.reason === undefined ? [] : ['(' + snapshot.reason + ')']),",
+	"  ...(snapshot.status === 'Pending' ? ['(akter dev serving ' + snapshot.environment + ' takes it)'] : []),",
+	"].join(' ');",
+	"const environmentLine = (environment) => [",
+	"  environment.name, environment.status,",
+	"  ...(environment.serving ? ['serving'] : []), ...(environment.quiet ? ['quiet'] : []),",
+	"  ...(environment.source === undefined ? [] : ['from ' + environment.source]), environment.directory,",
+	"].join(' ');",
+	String.raw`const each = (line) => (values) => values.map(line).join('\n');`
+];
+const operationLines = [
+	"const operations = {",
+	"  'snapshots create': { input: Snapshotting, run: (local, input) => local.createSnapshot(input), output: LocalSnapshot, line: snapshotLine },",
+	"  'snapshots list': { input: Of, run: (local, input) => local.snapshots(input.environment), output: Schema.Array(LocalSnapshot), line: each(snapshotLine) },",
+	"  'snapshots get': { input: Snapshotting, run: (local, input) => local.snapshot(input), output: LocalSnapshot, line: snapshotLine },",
+	"  'snapshots delete': { input: Snapshotting, run: (local, input) => local.deleteSnapshot(input), output: LocalSnapshot, line: snapshotLine },",
+	"  'environments list': { input: Of, run: (local) => local.environments, output: Schema.Array(LocalEnvironment), line: each(environmentLine) },",
+	"  'environments get': { input: Naming, run: (local, input) => local.environment(input.name), output: LocalEnvironment, line: environmentLine },",
+	"  'environments branch': { input: Branching, run: (local, input) => local.branch(input), output: LocalEnvironment, line: environmentLine },",
+	"  'environments promote': { input: Naming, run: (local, input) => local.promote(input.name), output: Promotion, line: (promotion) => promotion.notice },",
+	"  'environments delete': { input: Naming, run: (local, input) => local.deleteEnvironment(input.name), output: LocalEnvironment, line: environmentLine },",
+	"};"
+];
+const refusalLines = (json) => [
+	"const refused = (code, reason, message) => Effect.sync(() => {",
+	`  if (${json}) console.log(JSON.stringify({ code, reason, message }));`,
+	"  else console.error(command + ': ' + message);",
+	"  process.exitCode = code;",
+	"});",
+	"const refusals = {",
+	"  AlreadyExistsError: (error) => refused(1, 'AlreadyExists', 'the ' + error.resource + ' name ' + error.key + ' is taken'),",
+	"  InUseError: (error) => refused(1, 'InUse', error.key + ': ' + error.reason),",
+	"  NotFoundError: (error) => refused(1, 'NotFound', 'no live ' + error.resource + ' is named ' + error.key),",
+	"  SchemaError: (error) => refused(2, 'InvalidInput', error.message),",
+	"  StoreUnreadableError: (error) => refused(1, 'StoreUnreadable', error.message),",
+	"};"
+];
+/** The runner `akter dev environments` and `akter dev snapshots` write and run: one operation through `Akter.environments`. */
+const environmentRunner = ({ directory, input, json, operation }) => join([
+	"import { DateTime, Effect, Schema } from \"effect\";",
+	"import { Akter, EnvironmentName, LocalEnvironment, LocalEnvironments, LocalSnapshot, Promotion, SnapshotName } from \"@akterjs/effect\";",
+	"",
+	`const command = "akter dev " + ${operation};`,
+	...inputLines,
+	...lineLines,
+	...operationLines,
+	...refusalLines(json),
+	`const chosen = operations[${operation}];`,
+	`const shown = (value) => ${json} ? Effect.map(Schema.encodeEffect(Schema.toCodecJson(chosen.output))(value), JSON.stringify) : Effect.succeed(chosen.line(value));`,
+	`const program = Schema.decodeUnknownEffect(chosen.input)(${input}).pipe(`,
+	"  Effect.flatMap((decoded) => LocalEnvironments.use((local) => chosen.run(local, decoded))),",
+	"  Effect.flatMap(shown),",
+	"  Effect.flatMap((text) => Effect.sync(() => { if (text !== '') console.log(text); })),",
+	"  Effect.catchTags(refusals),",
+	`  Effect.provide(Akter.environments(${directory})),`,
+	");",
+	"",
+	"await Effect.runPromise(program);",
+	""
+], "\n");
+export { environmentRunner };

package/dist/local/local-cli.config.mjs

@@ -0,0 +1,159 @@
+import { n as Port, o as withDefault } from "../Config-B6OND9WR.mjs";
+import { t as error } from "../Console-BKHUkH6a.mjs";
+import { U as fn, _n as when } from "../Effect-CKFpqbmw.mjs";
+import { t as FileSystem } from "../FileSystem-4pPcEb_i.mjs";
+import { _ as isSome, b as map, c as flatten, f as getOrElse, h as isNone, p as getOrNull, r as exists } from "../Option-DkxSnBhp.mjs";
+import { t as Path } from "../Path-Djdv_eF5.mjs";
+import { F as String, O as NullOr, g as Finite, n as ArraySchema, pt as fromJsonString, st as encodeEffect } from "../Schema-MiKt5K1v.mjs";
+import { r as withDescription, t as String$1 } from "../Argument-D81dqizB.mjs";
+import { c as Int, f as optional, h as withFallbackConfig, i as withDescription$2, l as String$2, m as withDescription$1, o as Boolean, p as withDefault$1, t as make, u as atLeast } from "../Command-Dzq9KM-h.mjs";
+import { a as ChildProcessSpawner, n as make$1 } from "../ChildProcess-BCIwxPGc.mjs";
+import { importInto } from "../archive/archive-cli.config.mjs";
+import { entry } from "../app-cli.config.mjs";
+import { devRunner } from "../dev-runner.pure.mjs";
+import { historyRunner } from "../history-runner.pure.mjs";
+import { millisOf } from "../history-since.pure.mjs";
+import { migrateRunner } from "../migrate-runner.pure.mjs";
+import { RunnerExitedError } from "../runner-exited.errors.mjs";
+import { Confirmation } from "../terminal/confirm.adapter.mjs";
+// src/local/local-cli.config.ts
+const defaultPort = 4e3;
+const anyPort = 0;
+const nextPort = 1;
+const noneRequired = 0;
+const portFromEnvironment = Port("PORT").pipe(withDefault(defaultPort));
+const exitedCleanly = 0;
+const usageError = 2;
+const jsString = encodeEffect(fromJsonString(String));
+const jsSince = encodeEffect(fromJsonString(NullOr(Finite)));
+const jsNames = encodeEffect(fromJsonString(ArraySchema(String)));
+const jsEnvironment = encodeEffect(fromJsonString(NullOr(String)));
+const emptyFolder = fn("emptyFolder")(function* emptyFolder(directory) {
+	yield* Confirmation.use((confirmation) => confirmation.confirm({
+		question: `Delete everything in ${directory}?`,
+		unattended: `akter dev --reset deletes everything in ${directory} and needs a person to confirm it, and no terminal is attached to ask. Delete the folder yourself, then run akter dev.`
+	}));
+	yield* (yield* FileSystem).remove(directory, {
+		force: true,
+		recursive: true
+	});
+});
+const appSource = fn("appSource")(function* appSource(options) {
+	const path = yield* Path;
+	const entry = yield* path.toFileUrl(path.resolve(options.entry));
+	return {
+		directory: yield* jsString(path.resolve(options.dir)),
+		entry: yield* jsString(entry.href)
+	};
+});
+const writeRunner = fn("writeRunner")(function* writeRunner(name, source) {
+	const fileSystem = yield* FileSystem;
+	const path = yield* Path;
+	const runner = path.resolve("node_modules", ".akter", name);
+	const existing = yield* when(fileSystem.readFileString(runner), fileSystem.exists(runner));
+	if (exists(existing, (written) => written === source)) return runner;
+	yield* fileSystem.makeDirectory(path.dirname(runner), { recursive: true });
+	yield* fileSystem.writeFileString(runner, source);
+	return runner;
+});
+const runRunner = fn("runRunner")(function* runRunner(args) {
+	return yield* (yield* ChildProcessSpawner).exitCode(make$1(globalThis.process.execPath, args, {
+		stderr: "inherit",
+		stdin: "inherit",
+		stdout: "inherit"
+	}));
+});
+const inspectorPortOf = ({ inspectorPort, port }) => getOrElse(inspectorPort, () => {
+	if (port === anyPort) return anyPort;
+	return port + nextPort;
+});
+const portsOf = (options) => ({
+	inspectorPort: inspectorPortOf(options),
+	port: options.port
+});
+const serveDev = fn("serveDev")(function* serveDev(options) {
+	if (options.reset) yield* emptyFolder(options.dir);
+	if (isSome(options.from)) yield* importInto({
+		archive: options.from.value,
+		dir: options.dir
+	});
+	const app = yield* appSource(options);
+	const allowedHosts = yield* jsNames(options.allowedHosts);
+	const environment = yield* jsEnvironment(getOrNull(options.environment));
+	const source = devRunner({
+		...app,
+		allowedHosts,
+		environment,
+		...portsOf(options)
+	});
+	const runner = yield* writeRunner("dev.mjs", source);
+	return yield* runRunner(["--watch", runner]);
+});
+const migrateStore = fn("migrateStore")(function* migrateStore(options) {
+	if (!options.all) {
+		yield* error("akter migrate needs --all: migrating a single actor is not supported yet.");
+		return yield* RunnerExitedError.make({ code: usageError });
+	}
+	const app = yield* appSource(options);
+	const runner = yield* writeRunner("migrate.mjs", migrateRunner({
+		...app,
+		dryRun: options.dryRun
+	}));
+	const code = yield* runRunner([runner]);
+	if (code === exitedCleanly) return code;
+	return yield* RunnerExitedError.make({ code });
+});
+const historyWindow = fn("historyWindow")(function* historyWindow({ since, verify }) {
+	if (verify && isSome(since)) {
+		yield* error("akter history: --verify replays the whole kept history, so it takes no --since.");
+		return yield* RunnerExitedError.make({ code: usageError });
+	}
+	const millis = map(since, millisOf);
+	if (exists(millis, isNone)) {
+		yield* error("akter history: --since takes a whole number and a unit, like 90s, 30m, 1h or 7d.");
+		return yield* RunnerExitedError.make({ code: usageError });
+	}
+	return yield* jsSince(getOrNull(flatten(millis)));
+});
+const readHistory = fn("readHistory")(function* readHistory(options) {
+	const window = yield* historyWindow(options);
+	const app = yield* appSource(options);
+	const address = yield* jsString(options.actor);
+	const source = historyRunner({
+		...app,
+		address,
+		json: options.json,
+		since: window,
+		verify: options.verify
+	});
+	const runner = yield* writeRunner("history.mjs", source);
+	const code = yield* runRunner([runner]);
+	if (code === exitedCleanly) return code;
+	return yield* RunnerExitedError.make({ code });
+});
+const dir = String$2("dir").pipe(withDefault$1(".akter"), withDescription$1("The folder that holds the actors"));
+const dev = make("dev", {
+	allowedHosts: String$2("allowed-host").pipe(atLeast(noneRequired), withDescription$1("A name besides localhost, 127.0.0.1 and [::1] that /rpc and the inspector answer in the Host header, such as a dev proxy's hostname; repeat it for more")),
+	dir,
+	entry,
+	environment: String$2("environment").pipe(optional, withDescription$1("Serve this environment of the folder, such as a quiet branch to call before promoting it, instead of the one promoted to serve")),
+	from: String$2("from").pipe(optional, withDescription$1("An .akter archive to read into --dir first, which must not exist yet")),
+	inspectorPort: Int("inspector-port").pipe(optional, withDescription$1("The port the read-only actor inspector is served on, --port + 1 when missing")),
+	port: Int("port").pipe(withFallbackConfig(portFromEnvironment), withDescription$1("The port /rpc is served on, PORT when the flag is missing")),
+	reset: Boolean("reset").pipe(withDefault$1(false), withDescription$1("Empty the folder first, after a confirmation"))
+}, serveDev).pipe(withDescription$2("Run the app on the local engine, restarting when its files change"));
+const migrate = make("migrate", {
+	all: Boolean("all").pipe(withDefault$1(false), withDescription$1("Apply pending migrations to every actor in the folder now")),
+	dir,
+	dryRun: Boolean("dry-run").pipe(withDefault$1(false), withDescription$1("List each actor's old and new version without writing")),
+	entry
+}, migrateStore).pipe(withDescription$2("Apply pending actor state migrations to the local folder"));
+const history = make("history", {
+	actor: String$1("actor").pipe(withDescription("The actor to read, as <Actor>/<key>, like Room/lobby")),
+	dir,
+	entry,
+	json: Boolean("json").pipe(withDefault$1(false), withDescription$1("Print one JSON object per command instead of one line of text")),
+	since: String$2("since").pipe(optional, withDescription$1("Only the commands from this long ago until now, like 30m, 1h or 7d")),
+	verify: Boolean("verify").pipe(withDefault$1(false), withDescription$1("Rerun the kept history against the current handlers and print the first command that differs"))
+}, readHistory).pipe(withDescription$2("Print the commands a local actor kept, or replay them with --verify"));
+export { dev, dir, history, migrate, runRunner, writeRunner };

package/dist/logs/log-follow.config.mjs

@@ -0,0 +1,21 @@
+import { Mt as provideServiceEffect } from "../Effect-CKFpqbmw.mjs";
+import { c as Int, f as optional, i as withDescription$1, l as String, m as withDescription, o as Boolean, p as withDefault, t as make } from "../Command-Dzq9KM-h.mjs";
+import { LogFollow } from "./log-follow.service.mjs";
+// src/logs/log-follow.config.ts
+const described = (flag, description) => flag.pipe(optional, withDescription(description));
+const followNamed = (name) => make(name, {
+	app: String("app").pipe(withDescription("The app whose lines to print")),
+	count: Int("count").pipe(optional, withDescription("Stop after this many lines")),
+	deploy: described(String("deploy"), "Only the lines about this deploy, such as dep_123"),
+	json: Boolean("json").pipe(withDefault(false), withDescription("Print each line as one line of JSON in the API's LogLine schema")),
+	organization: described(String("organization"), "The organization; defaults to AKTER_ORGANIZATION, then the one saved by akter login"),
+	since: described(String("since"), "Only the lines since this time, such as 2026-11-11T00:00:00Z"),
+	source: described(String("source"), "Only the lines this source wrote: deploy or computer"),
+	url: described(String("url"), "The Cloud API's URL; defaults to AKTER_CLOUD_URL, then the one saved by akter login, then https://api.akter.dev")
+}, (options) => LogFollow.use((logs) => logs.follow(options)).pipe(provideServiceEffect(LogFollow, LogFollow.make))).pipe(withDescription$1("Print an app's log lines as they arrive, oldest first, until interrupted or --count lines have printed"));
+const logCommands = { logs: {
+	commands: [followNamed("follow")],
+	description: "Read an app's log lines",
+	serves: []
+} };
+export { logCommands };

package/dist/logs/log-follow.service.mjs

@@ -0,0 +1,87 @@
+import { C as isReadonlyArrayEmpty } from "../Array-B4kuTQeW.mjs";
+import { t as match } from "../Boolean-kILIvmhE.mjs";
+import { n as log, t as error } from "../Console-BKHUkH6a.mjs";
+import { At as provideContext, B as flatMap, Et as orDie, Lt as retry, T as context, U as fn, Vn as effect, Xt as succeed, Yt as sleep, _n as when, aa as Service, et as gen, ht as mapError, ln as try_, o as andThen, x as catchTag, y as catchIf } from "../Effect-CKFpqbmw.mjs";
+import { C as orElse, S as none, d as fromUndefinedOr, w as some, x as match$1 } from "../Option-DkxSnBhp.mjs";
+import { I as Struct, cr as getSomes, pt as fromJsonString, st as encodeEffect, tt as decodeEffect } from "../Schema-MiKt5K1v.mjs";
+import { P as paginate, W as runForEach, Y as take } from "../Stream-bK9QIETN.mjs";
+import { c as LogLine, l as LogsReadParams, t as AppName, u as OrganizationName } from "../cloud-client.adapter-Cy1BjDbG.mjs";
+import { Credentials } from "../credentials/credentials.service.mjs";
+import { t as CloudClient } from "../cloud-client.adapter-DOVMoYAj.mjs";
+import { progressWait, reconnectBackoff, retryable } from "../deploy/request-failure.pure.mjs";
+import { lineText, retryNotice, stopped } from "./log-lines.pure.mjs";
+import { reported } from "../registry/operation-output.pure.mjs";
+import { CliExitError } from "../terminal/cli-exit.errors.mjs";
+// src/logs/log-follow.service.ts
+const Path = Struct({
+	app: AppName,
+	organization: OrganizationName
+});
+const LineJson = fromJsonString(LogLine);
+const idleWait = "2 seconds";
+const usage = (message) => CliExitError.make({
+	code: CliExitError.codes.usage,
+	message,
+	reason: "InvalidInput"
+});
+const paramsOf = (options) => mapError(decodeEffect(LogsReadParams)(getSomes({
+	deploy: options.deploy,
+	since: options.since,
+	source: options.source
+})), (failure) => usage(`Invalid --deploy, --since or --source: ${failure.message}`));
+const pageAfter = ({ cloud, params, path }) => (cursor) => {
+	const read = cloud.request(cloud.client.logsRead(path.organization, path.app, { params: match$1(cursor, {
+		onNone: () => params,
+		onSome: (after) => ({
+			...params,
+			cursor: after
+		})
+	}) }), progressWait);
+	return read.pipe(catchIf(retryable, (failure) => error(retryNotice(failure)).pipe(andThen(retry(read, {
+		schedule: reconnectBackoff,
+		while: retryable
+	})))), mapError(stopped));
+};
+const linesOf = (reading) => paginate(none(), (cursor) => gen(function* nextPage() {
+	const page = yield* pageAfter(reading)(cursor);
+	const next = orElse(fromUndefinedOr(page.nextCursor), () => cursor);
+	yield* when(sleep(idleWait), succeed(isReadonlyArrayEmpty(page.items)));
+	return [page.items, some(next)];
+}));
+const printed = (json) => (line) => match(json, {
+	onFalse: () => log(lineText(line)),
+	onTrue: () => flatMap(orDie(encodeEffect(LineJson)(line)), (text) => log(text))
+});
+const followed = fn("followed")(function* followed(options) {
+	const target = yield* Credentials.use((credentials) => credentials.target(options));
+	const path = yield* mapError(decodeEffect(Path)({
+		...target,
+		app: options.app
+	}), () => usage("--app and --organization must be valid Cloud names."));
+	const params = yield* paramsOf(options);
+	const url = yield* try_({
+		catch: () => usage(`${target.url} is not a URL.`),
+		try: () => new globalThis.URL(target.url)
+	});
+	const cloud = yield* CloudClient.use((factory) => factory.connect({
+		apiKey: target.apiKey,
+		url
+	}));
+	const lines = linesOf({
+		cloud,
+		params,
+		path
+	});
+	const limited = match$1(options.count, {
+		onNone: () => lines,
+		onSome: (count) => take(lines, count)
+	});
+	yield* runForEach(limited, printed(options.json));
+});
+var LogFollow = class extends Service()("@akterjs/cli/logs/log-follow.service/LogFollow", { make: gen(function* makeLogFollow() {
+	const context$1 = yield* context();
+	return { follow: (options) => followed(options).pipe(catchTag("CliExitError", reported(options.json)), provideContext(context$1)) };
+}) }) {
+	static layer = effect(this, this.make);
+};
+export { LogFollow };

package/dist/logs/log-lines.pure.mjs

@@ -0,0 +1,44 @@
+import { ti as isTimeoutError } from "../Effect-CKFpqbmw.mjs";
+import { h as isNone, x as match } from "../Option-DkxSnBhp.mjs";
+import { Xt as isSchemaError, mt as is } from "../Schema-MiKt5K1v.mjs";
+import { l as isHttpClientError } from "../HttpClientError-BUeMWx70.mjs";
+import { TokenRefreshError } from "../deploy/auth/token-refresh.errors.mjs";
+import { DeployFailedError } from "../deploy/deploy-failed.errors.mjs";
+import { progressStatus, progressWait, statusOf } from "../deploy/request-failure.pure.mjs";
+import { unanswered } from "../registry/operation-output.pure.mjs";
+import { CliExitError } from "../terminal/cli-exit.errors.mjs";
+// src/logs/log-lines.pure.ts
+const command = "akter logs follow";
+const lineText = ({ at, level, message, source, subject }) => `${at} ${level} [${source} ${subject}] ${message}`;
+const refused = (failure) => CliExitError.make({
+	code: match(progressStatus(failure), {
+		onNone: () => CliExitError.codes.failed,
+		onSome: CliExitError.ofStatus
+	}),
+	message: `${command} was refused (${statusOf(failure)}).`,
+	reason: "Refused"
+});
+const stopped = (failure) => {
+	if (isSchemaError(failure)) return CliExitError.make({
+		code: CliExitError.codes.failed,
+		message: `${command} read a page that breaks the API's schema, so this CLI and the API disagree.`,
+		reason: "ResponseMismatch"
+	});
+	if (is(DeployFailedError)(failure) || is(TokenRefreshError)(failure) || isTimeoutError(failure)) return unanswered({
+		command,
+		failure,
+		wait: progressWait
+	});
+	if (isHttpClientError(failure) && isNone(progressStatus(failure))) return unanswered({
+		command,
+		failure,
+		wait: progressWait
+	});
+	return refused(failure);
+};
+const retryNotice = (failure) => {
+	if (is(TokenRefreshError)(failure)) return `${failure.message} Retrying.`;
+	if (isTimeoutError(failure)) return `${command} got no answer within ${progressWait}. Retrying.`;
+	return `${command} could not read the next lines (${statusOf(failure)}). Retrying.`;
+};
+export { lineText, retryNotice, stopped };

package/dist/migrate-runner.pure.mjs

@@ -0,0 +1,28 @@
+import { T as join } from "./Array-B4kuTQeW.mjs";
+import { appEntry } from "./app-entry.pure.mjs";
+// src/migrate-runner.pure.ts
+const migrateRunner = ({ directory, dryRun, entry }) => join([
+	"import { Console, Effect, Layer, Stream } from \"effect\";",
+	"import { Akter } from \"@akterjs/effect\";",
+	...appEntry({
+		command: "migrate",
+		entry
+	}),
+	"const named = (actor) => actor.actor + \" \" + JSON.stringify(actor.key);",
+	"const report = (actor) => Console.log(named(actor) + \": version \" + actor.from + \" -> \" + actor.to);",
+	"const failed = (line) => Effect.andThen(Console.error(line), Effect.sync(() => { process.exitCode = 1; }));",
+	"const stopped = (error) =>",
+	"  failed(\"akter migrate: stopped at \" + named(error) + \": \" + error.message + \". The actors after it were not touched.\");",
+	"const unreadable = (error) => failed(\"akter migrate: could not read \" + error.directory + \": \" + error.message);",
+	`const migrations = Akter.migrate({ directory: ${directory}, dryRun: ${dryRun} });`,
+	"",
+	`if (${dryRun}) console.log("akter migrate --dry-run: nothing is written");`,
+	"await Effect.runPromise(",
+	"  Stream.runForEach(migrations, report).pipe(",
+	"    Effect.catchTags({ ActorNotMigratedError: stopped, StoreUnreadableError: unreadable }),",
+	"    Effect.provide(app.layer.pipe(Layer.provide(Akter.jobs))),",
+	"  ),",
+	");",
+	""
+], "\n");
+export { migrateRunner };