@letterstory/cli 0.84.0 → 0.86.0

package/README.md

@@ -644,6 +644,10 @@ letterstory org join acme/ > acme.json             # rebuild the identical bundl
 letterstory org diff acme.json                     # what applying the bundle would change: + add, ~ change, - only in the org
 letterstory org apply acme.json --dry-run           # what apply would write; then drop --dry-run to apply
 letterstory org apply acme.json --prune --yes      # also delete records the bundle lacks
+letterstory org git connect acme/config --path letterstory/org.json   # keep the config in GitHub: each new commit is planned and posted to Slack
+letterstory org git connect acme/config --mode apply                   # …or applied (deletes only with --prune)
+letterstory org git status                         # the connected repo and its last sync
+letterstory org git sync [--force]                 # sync now instead of waiting for the 15-minute poll
 ```
 
 ## Seers — event-driven signals

package/lib/cli.mjs

@@ -57,7 +57,7 @@ import {
 } from "./commands.mjs";
 
 // Keep in sync with cli/package.json.
-export const VERSION = "0.84.0";
+export const VERSION = "0.86.0";
 
 // Flags that never take a value. Listing them explicitly means `deploy get --json <id>`
 // can't accidentally swallow the id as --json's value. Every `type: "bool"` flag (and its
@@ -77,6 +77,8 @@ export const BOOLEAN_FLAGS = new Set([
 	"no-color",
 	"dry-run",
 	"prune",
+	// org git sync --force
+	"force",
 	"buy",
 	"rebuild",
 	"print-key",
@@ -816,6 +818,7 @@ Seers (event-driven signals -> drafts):
   org join <dir> [--file <path>]                       Rebuild the bundle from a --split directory
   org diff <file|dir>                                  What applying a bundle would change (reads only)
   org apply <file|dir> [--dry-run] [--prune --yes]     Make the org match a bundle (adds/updates; --prune deletes)
+                [--allow spends,sends,destroys --yes]  Also apply gated changes (admins; without --yes it only previews)
 
 Content templates (compose structures seers bind via config.template_key):
   templates list                                       Custom + built-in catalog
@@ -963,7 +966,9 @@ Sequences (multi-step cold email sent from your mailers; approving or enrolling
            [--[no-]opt-out-footer] [--[no-]postal-address-footer] [--[no-]unsubscribe-links] [--[no-]detect-reply-opt-outs]
            [--[no-]test-mode] [--default-lede <fallback opener line>]
            [--send-window-start <HH:MM>] [--send-window-end <HH:MM>] [--send-window-timezone <IANA tz>]
+           [--enroll-on-cake paid|scheduled|out_for_delivery|delivered|none]
                                                        --test-mode (internal accounts only): walks as live, sends nothing
+                                                       --enroll-on-cake: start it when a recipient's Daymaker cake reaches that stage
   sequences pause|resume <sequence-id>                 Stop / restart sending
   sequences enroll <sequence-id> (--list <list-id> | --email <addr>... | --recipients '<json>'|--recipients-file <path>)
   sequences stop <sequence-id> <enrollment-id>         Stop one recipient
@@ -973,6 +978,10 @@ Sequences (multi-step cold email sent from your mailers; approving or enrolling
   sequences links list                                 Live Pocket Dispatch links (no tokens)
   sequences links create --days <1..3>                 Mint a no-login review link (shown once)
   sequences links revoke <link-id> --yes
+  sequences cakes [--stage <stage>] [--limit <n>]      Daymaker cakes: stage, matched prospect, sequences started
+  sequences cakes sync                                 Re-read the connected Daymaker account now
+  sequences cakes connect --daymaker-key <dm_live_…>   Connect the org's Daymaker account (key checked, stored encrypted)
+  sequences cakes disconnect                           Forget the key and remove the webhook
 
 Dispatches (the named review desks a sequence's review stage queues to):
   dispatches list                                      Desks + how many emails each has queued

package/lib/commands/org.mjs

@@ -22,7 +22,21 @@ export const ARGS = {
 		config: { value: (_flags, positionals) => readBundle(requirePositional(positionals, 0, "file|dir")) },
 		dry_run: { flag: "dry-run", type: "bool" },
 		prune: { flag: "prune", type: "bool" },
+		allow: { flag: "allow", type: "list" },
+		confirm: { flag: "confirm" },
 	},
+	get_org_config_source: {},
+	connect_org_config_source: {
+		repo: { positional: 0, label: "owner/name" },
+		branch: { flag: "branch" },
+		path: { flag: "path" },
+		mode: { flag: "mode" },
+		prune: { flag: "prune", type: "bool" },
+	},
+	sync_org_config_source: {
+		force: { flag: "force", type: "bool" },
+	},
+	disconnect_org_config_source: {},
 };
 
 export async function cmdOrg(ctx) {
@@ -37,8 +51,10 @@ export async function cmdOrg(ctx) {
 			return orgDiff(rest);
 		case "apply":
 			return orgApply(rest);
+		case "git":
+			return orgGit(rest);
 		default:
-			throw new CliError(`Unknown org subcommand: ${sub ?? "(none)"}. Try: export, join, diff, apply`);
+			throw new CliError(`Unknown org subcommand: ${sub ?? "(none)"}. Try: export, join, diff, apply, git`);
 	}
 }
 
@@ -204,6 +220,10 @@ export function formatApply(result) {
 	for (const a of result.skipped) lines.push(`  ${SYMBOL[a.op]} ${a.section}/${a.name} — ${a.reason}`);
 	if (result.failed.length) lines.push("Failed:");
 	for (const a of result.failed) lines.push(`  ${SYMBOL[a.op]} ${a.section}/${a.name} — ${a.error}`);
+	if (result.gated?.length) {
+		lines.push(`Gated (allow with --allow; confirm ${result.confirm}):`);
+		for (const a of result.gated) lines.push(`  ${SYMBOL[a.op]} ${a.section}/${a.name} — ${a.gate}`);
+	}
 	for (const w of result.plan.warnings) lines.push(`warning: ${w}`);
 	return lines.join("\n");
 }
@@ -213,10 +233,92 @@ async function orgApply(ctx) {
 	refuseUnknownFlags(ctx, ARGS.apply_org_config, ["yes"]);
 	if (flagBool(flags.prune) && !flagBool(flags["dry-run"]) && !flagBool(flags.yes))
 		throw new CliError("--prune deletes records missing from the bundle. Review with --dry-run, then add --yes.");
-	const { result } = await client.callTool(
-		"apply_org_config",
-		argsFromFlags(ARGS.apply_org_config, flags, ctx.positionals)
-	);
+	const args = argsFromFlags(ARGS.apply_org_config, flags, ctx.positionals);
+	if (args.allow)
+		args.allow = args.allow
+			.flatMap((g) => g.split(","))
+			.map((g) => g.trim())
+			.filter(Boolean);
+	if (args.allow?.length && !args.dry_run && !args.confirm) {
+		// Gated changes need the plan's hash: dry-run to get it, show what it unlocks, then apply with it.
+		const { result: plan } = await client.callTool("apply_org_config", { ...args, dry_run: true });
+		const unlocked = (plan.gated ?? []).filter((g) => args.allow.includes(g.gate));
+		if (unlocked.length && !flagBool(flags.yes)) {
+			printResult(io, flags, plan, formatApply);
+			throw new CliError(
+				`--allow ${args.allow.join(",")} unlocks ${unlocked.length} gated change(s) above. Re-run with --yes to apply them.`
+			);
+		}
+		args.confirm = plan.confirm ?? undefined;
+	}
+	const { result } = await client.callTool("apply_org_config", args);
 	printResult(io, flags, result, formatApply);
 	return result.failed.length ? 1 : 0;
 }
+
+export function formatSource(source) {
+	if (!source) return "No config repo connected. Connect one with `org git connect <owner/name>`.";
+	const lines = [
+		`${source.repo}@${source.branch}:${source.path} — mode ${source.mode}${source.prune ? " (prune)" : ""}`,
+		`  last seen:    ${source.last_seen_sha?.slice(0, 7) ?? "—"}${source.last_synced_at ? ` at ${source.last_synced_at}` : ""}`,
+		`  last applied: ${source.last_applied_sha?.slice(0, 7) ?? "—"}`,
+	];
+	if (source.last_error) lines.push(`  last error:   ${source.last_error}`);
+	return lines.join("\n");
+}
+
+function formatSync(outcome) {
+	const at = outcome.sha ? outcome.sha.slice(0, 7) : "?";
+	if (outcome.status === "unchanged")
+		return `Already synced ${at} — nothing new on the branch (use --force to re-run it).`;
+	if (outcome.status === "error") return `Sync failed at ${at}: ${outcome.error}`;
+	if (outcome.status === "planned") return `Planned ${at} (plan mode, nothing applied):\n${formatPlan(outcome.plan)}`;
+	return `Applied ${at}:\n${formatApply(outcome.result)}`;
+}
+
+async function orgGit(ctx) {
+	const { client, flags, io } = ctx;
+	const sub = ctx.positionals[0];
+	const rest = { ...ctx, positionals: ctx.positionals.slice(1) };
+	switch (sub) {
+		case "status": {
+			refuseUnknownFlags(rest, ARGS.get_org_config_source);
+			const { source } = await client.callTool("get_org_config_source", {});
+			printResult(io, flags, source, formatSource);
+			return 0;
+		}
+		case "connect": {
+			refuseUnknownFlags(rest, ARGS.connect_org_config_source);
+			const out = await client.callTool(
+				"connect_org_config_source",
+				argsFromFlags(ARGS.connect_org_config_source, flags, rest.positionals)
+			);
+			printResult(io, flags, out, (o) =>
+				[
+					`Connected ${o.org} to ${formatSource(o.source)}`,
+					`The next sync ${o.source.mode === "apply" ? "applies" : "plans"} ${o.head.slice(0, 7)} — run \`org git sync\` to do it now.`,
+				].join("\n")
+			);
+			return 0;
+		}
+		case "sync": {
+			refuseUnknownFlags(rest, ARGS.sync_org_config_source);
+			const { outcome } = await client.callTool(
+				"sync_org_config_source",
+				argsFromFlags(ARGS.sync_org_config_source, flags)
+			);
+			printResult(io, flags, outcome, formatSync);
+			return outcome.status === "error" ? 1 : 0;
+		}
+		case "disconnect": {
+			refuseUnknownFlags(rest, ARGS.disconnect_org_config_source);
+			const { disconnected } = await client.callTool("disconnect_org_config_source", {});
+			ok(ctx, disconnected ? "Disconnected the config repo." : "No config repo was connected.");
+			return 0;
+		}
+		default:
+			throw new CliError(
+				`Unknown org git subcommand: ${sub ?? "(none)"}. Try: status, connect, sync, disconnect`
+			);
+	}
+}

package/lib/commands/outbound.mjs

@@ -89,6 +89,21 @@ const SEQUENCE_WINDOW_ARGS = {
 	send_window_end_minute: { value: windowMinute("send-window-end") },
 	send_window_timezone: "send-window-timezone",
 };
+// --enroll-on-cake <stage>: start the sequence when a recipient's Daymaker cake
+// reaches it; `none` clears it.
+const CAKE_TRIGGER_STAGES = ["paid", "scheduled", "out_for_delivery", "delivered"];
+const CAKE_STAGES = ["draft", ...CAKE_TRIGGER_STAGES, "delivery_failed", "cancelled"];
+const enrollOnCake = {
+	value: (flags) => {
+		const raw = flagStr(flags["enroll-on-cake"]);
+		if (raw === undefined) return undefined;
+		if (raw === "none") return null;
+		if (!CAKE_TRIGGER_STAGES.includes(raw)) {
+			throw new CliError(`--enroll-on-cake takes ${CAKE_TRIGGER_STAGES.join(", ")} or none (got ${raw})`);
+		}
+		return raw;
+	},
+};
 const PROSPECT_STATUSES = ["new", "contacted", "replied", "unsubscribed", "archived"];
 const mailerIds = {
 	value: (flags) => {
@@ -147,6 +162,7 @@ export const ARGS = {
 		mailer_ids: mailerIds,
 		...SEQUENCE_RAIL_ARGS,
 		...SEQUENCE_WINDOW_ARGS,
+		enroll_on_cake: enrollOnCake,
 	},
 	update_sequence: {
 		sequence_id: { positional: 0, label: "sequence-id", required: true },
@@ -156,7 +172,15 @@ export const ARGS = {
 		mailer_ids: mailerIds,
 		...SEQUENCE_RAIL_ARGS,
 		...SEQUENCE_WINDOW_ARGS,
+		enroll_on_cake: enrollOnCake,
 	},
+	list_cakes: {
+		stage: { flag: "stage", enum: CAKE_STAGES },
+		limit: { flag: "limit", type: "num" },
+	},
+	sync_cakes: {},
+	connect_daymaker: { api_key: { flag: "daymaker-key", required: true } },
+	disconnect_daymaker: {},
 	enroll_in_sequence: {
 		sequence_id: { positional: 0, label: "sequence-id", required: true },
 		recipients: { value: readRecipients },
@@ -357,7 +381,7 @@ async function run(ctx, tool, message) {
 	return 0;
 }
 
-const SEQUENCES_USAGE = `Usage: sequences <list|get|create|update|pause|resume|enroll|stop|review|links>`;
+const SEQUENCES_USAGE = `Usage: sequences <list|get|create|update|pause|resume|enroll|stop|review|links|cakes>`;
 const DISPATCHES_USAGE = `Usage: dispatches <list|create|rename|delete>`;
 
 // Dispatches: the named review desks a sequence's review stage queues to.
@@ -425,6 +449,19 @@ export async function cmdSequences(ctx) {
 			return sequencesReview({ ...rest, positionals: rest.positionals.slice(1) }, rest.positionals[0]);
 		case "links":
 			return sequencesLinks({ ...rest, positionals: rest.positionals.slice(1) }, rest.positionals[0]);
+		case "cakes": {
+			const cakesCtx = { ...rest, positionals: rest.positionals.slice(1) };
+			switch (rest.positionals[0]) {
+				case "sync":
+					return run(cakesCtx, "sync_cakes", "Synced cakes from Daymaker.");
+				case "connect":
+					return run(cakesCtx, "connect_daymaker", "Daymaker connected.");
+				case "disconnect":
+					return run(cakesCtx, "disconnect_daymaker", "Daymaker disconnected.");
+				default:
+					return run(rest, "list_cakes");
+			}
+		}
 		default:
 			throw new CliError(`Unknown sequences subcommand: ${sub ?? "(none)"}. ${SEQUENCES_USAGE}`);
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@letterstory/cli",
-	"version": "0.84.0",
+	"version": "0.86.0",
 	"description": "Spin up and manage Letterstory phantom blogs from your terminal.",
 	"type": "module",
 	"license": "UNLICENSED",