@cowliss/cli 0.1.0 → 0.2.0

package/dist/guest/{driver-BOe7jBFw.js → driver-D8cPyQgF.js}

@@ -1,4 +1,4 @@
-import { a as manifestOutputSchema, i as journeyStepOutputSchema, o as templateRenderOutputSchema, r as guestInputSchema, t as CapabilityError } from "./journeys-CxuS-mHn.js";
+import { a as manifestOutputSchema, i as journeyStepOutputSchema, o as templateRenderOutputSchema, r as guestInputSchema, t as CapabilityError } from "./journeys-CR_wIAtP.js";
 import { z } from "zod";
 import { createElement } from "react";
 import { renderToStaticMarkup } from "react-dom/server.browser";

package/dist/guest/driver.js

@@ -1,3 +1,3 @@
-import { t as runGuest } from "./driver-BOe7jBFw.js";
+import { t as runGuest } from "./driver-D8cPyQgF.js";
 
 export { runGuest };

package/dist/guest/{journeys-CxuS-mHn.js → journeys-CR_wIAtP.js}

@@ -69,19 +69,31 @@ const COW_CONFIG_SCHEMA_URL = `${DOCS_URL}${COW_CONFIG_SCHEMA_PATH}`;
 //#endregion
 //#region ../../packages/shared/src/journeys-v2/config.ts
 /**
-* `cow.json` (spec: Project layout): the org id and nothing more. The
-* folder name is the project's local name, the environment is always a
-* flag, and auth never lives in the project. Strict, so a typo'd key is a
-* build error rather than a silently ignored setting.
+* A project's name: what `cow init` asked for, and what the `projects` row
+* stores. Lives here rather than beside the release DTOs because `cow.json`
+* is the file a developer types it into; `createProjectBodySchema` reuses it.
+*/
+const projectNameSchema = z.string().trim().min(1).max(200);
+/**
+* `cow.json` (spec: Project layout): the org, and which of its projects this
+* directory is. The environment is always a flag, and auth never lives in
+* the project. Strict, so a typo'd key is a build error rather than a
+* silently ignored setting.
 */
 const cowConfigSchema = z.strictObject({
 	$schema: z.url().optional(),
 	orgId: z.string().startsWith(CLERK_ORG_SUBJECT_PREFIX, "orgId must be a Clerk org id"),
+	/**
+	* Which project of the org this directory pushes to. One org can hold
+	* several, one per repo, each with its own release sequence and its own
+	* slice of the deployed journeys, so every project says which it is.
+	*/
+	project: projectNameSchema,
 	/** Overrides the API the CLI talks to; the hosted product needs none. */
 	apiUrl: z.url().optional()
 }).meta({
 	title: "cow.json",
-	description: "A cow project: the organization it deploys to."
+	description: "A cow project: the organization and the project it deploys to."
 });
 
 //#endregion

package/dist/guest/journeys.js

@@ -1,3 +1,3 @@
-import { n as defineJourney, t as CapabilityError } from "./journeys-CxuS-mHn.js";
+import { n as defineJourney, t as CapabilityError } from "./journeys-CR_wIAtP.js";
 
 export { CapabilityError, defineJourney };

package/dist/guest/wasi.js

@@ -1,4 +1,4 @@
-import { t as runGuest } from "./driver-BOe7jBFw.js";
+import { t as runGuest } from "./driver-D8cPyQgF.js";
 
 //#region src/guest/wasi.ts
 const STDIN = 0;

package/dist/index.js

@@ -3802,13 +3802,18 @@ const insertJourneyRunSchema = createInsertSchema(journeyRuns);
 */
 const consentPurposeEnum = pgEnum("consent_purpose", ["emailMarketing", "dataProcessing"]);
 /**
-* Derived journey rows: one per (org, environment, key), rebuilt from the
+* Derived journey rows: one per (org, environment, key), upserted from the
 * manifest inside the deploy transaction. Nothing here is authored through
 * the API, which is why there is no id of its own: the key is the name the
 * author gave the file, and the (org, environment, key) triple is the only
-* identity a journey has. Deleting and reinserting these rows on every
-* deploy is the point, so the row set always matches the environment's
-* current release.
+* identity a journey has.
+*
+* A deploy only ever adds and updates: it owns the keys its release carries
+* and leaves every other row alone, because an org's journeys can come from
+* several projects and a developer may deploy a release holding only some of
+* the files. `projectId` records which project put the row here, which is
+* what makes a key another project owns a refused deploy rather than a silent
+* overwrite. Removing a journey is an explicit delete (ADR 0009).
 *
 * `active` is the author's own rollout gate, flattened from the manifest's
 * `environments` list into this row's environment. The operator's kill
@@ -3823,8 +3828,10 @@ const journeys$1 = pgTable("journeys", {
 	orgId: text("org_id").notNull(),
 	environment: environmentEnum("environment").notNull(),
 	key: text("key").notNull(),
-	/** The release these rows were derived from; the environment's current one. */
+	/** The release this row was derived from; the one its executions run. */
 	releaseId: text("release_id").notNull(),
+	/** The project whose deploy owns this key in this environment. */
+	projectId: text("project_id").notNull(),
 	/** The author's labels, from the manifest; the dashboard's only grouping. */
 	tags: text("tags").array().notNull().default(sql`'{}'::text[]`),
 	trigger: jsonb("trigger").$type().notNull(),
@@ -3932,9 +3939,10 @@ const insertOrgSettingsSchema = createInsertSchema(orgSettings);
 //#region ../../packages/db/src/schema/projects.ts
 /**
 * An org's cow project: the folder a developer runs `cow init` in, and the
-* thing releases belong to. One per org for now (the unique index says so);
-* the row exists rather than hanging releases off the org id directly so
-* many projects per org is additive later without a migration of releases.
+* thing releases belong to. An org may hold several, one per repo, each with
+* its own release sequence, its own current release per environment, and its
+* own slice of the deployed journey rows. The name is how `cow.json` picks
+* one, so it is unique within the org.
 */
 const projects = pgTable("projects", {
 	id: text("id").primaryKey(),
@@ -3942,7 +3950,7 @@ const projects = pgTable("projects", {
 	name: text("name").notNull(),
 	createdAt: createdAt(),
 	updatedAt: updatedAt()
-}, (table) => [uniqueIndex("projects_org_id_unique").on(table.orgId)]);
+}, (table) => [uniqueIndex("projects_org_id_name_unique").on(table.orgId, table.name)]);
 const selectProjectSchema = createSelectSchema(projects);
 const insertProjectSchema = createInsertSchema(projects);
 
@@ -4087,19 +4095,23 @@ const releaseArtifacts = pgTable("release_artifacts", {
 	table.digest
 ] })]);
 /**
-* Append-only: an environment's current release is its latest row, and
-* rollback is another deployment of an earlier release rather than a
-* mutation. That is what makes the deployment history readable and makes
-* "the last two deployments" the whole of `cow rollback`.
+* Append-only: an environment's current release, for one project, is that
+* project's latest row, and rollback is another deployment of an earlier
+* release rather than a mutation. That is what makes the deployment history
+* readable and makes "the last two deployments" the whole of `cow rollback`.
+*
+* `projectId` is the release's own project, denormalised so "this project's
+* latest deployment in this environment" is one indexed read.
 */
 const deployments$1 = pgTable("deployments", {
 	id: text("id").primaryKey(),
 	orgId: text("org_id").notNull(),
 	environment: environmentEnum("environment").notNull(),
 	releaseId: text("release_id").notNull().references(() => releases$1.id),
+	projectId: text("project_id").notNull().references(() => projects.id),
 	deployedBy: text("deployed_by").notNull(),
 	createdAt: createdAt()
-}, (table) => [index("deployments_org_id_environment_created_at_idx").on(table.orgId, table.environment, table.createdAt)]);
+}, (table) => [index("deployments_org_id_environment_created_at_idx").on(table.orgId, table.environment, table.createdAt), index("deployments_org_id_project_id_environment_created_at_idx").on(table.orgId, table.projectId, table.environment, table.createdAt)]);
 const selectDeploymentSchema = createSelectSchema(deployments$1);
 const insertDeploymentSchema = createInsertSchema(deployments$1);
 
@@ -5901,19 +5913,31 @@ const dryRunJourneyBodySchema = z.object({ data: z.object({ profileId: z.string(
 //#endregion
 //#region ../../packages/shared/src/journeys-v2/config.ts
 /**
-* `cow.json` (spec: Project layout): the org id and nothing more. The
-* folder name is the project's local name, the environment is always a
-* flag, and auth never lives in the project. Strict, so a typo'd key is a
-* build error rather than a silently ignored setting.
+* A project's name: what `cow init` asked for, and what the `projects` row
+* stores. Lives here rather than beside the release DTOs because `cow.json`
+* is the file a developer types it into; `createProjectBodySchema` reuses it.
+*/
+const projectNameSchema = z.string().trim().min(1).max(200);
+/**
+* `cow.json` (spec: Project layout): the org, and which of its projects this
+* directory is. The environment is always a flag, and auth never lives in
+* the project. Strict, so a typo'd key is a build error rather than a
+* silently ignored setting.
 */
 const cowConfigSchema = z.strictObject({
 	$schema: z.url().optional(),
 	orgId: z.string().startsWith(CLERK_ORG_SUBJECT_PREFIX, "orgId must be a Clerk org id"),
+	/**
+	* Which project of the org this directory pushes to. One org can hold
+	* several, one per repo, each with its own release sequence and its own
+	* slice of the deployed journeys, so every project says which it is.
+	*/
+	project: projectNameSchema,
 	/** Overrides the API the CLI talks to; the hosted product needs none. */
 	apiUrl: z.url().optional()
 }).meta({
 	title: "cow.json",
-	description: "A cow project: the organization it deploys to."
+	description: "A cow project: the organization and the project it deploys to."
 });
 
 //#endregion
@@ -6000,7 +6024,9 @@ const projectSchema = selectProjectSchema.extend({
 	updatedAt: z.iso.datetime()
 });
 /** `cow init` names the project after the folder it created. */
-const createProjectBodySchema = z.object({ data: z.object({ name: z.string().trim().min(1).max(200) }) });
+const createProjectBodySchema = z.object({ data: z.object({ name: projectNameSchema }) });
+/** Which project to read: the one the caller's `cow.json` names. */
+const getProjectQuerySchema = z.object({ name: projectNameSchema });
 const artifactDigestParams = z.object({ digest: digestSchema });
 /**
 * Which kind of artifact the uploaded bytes are. Named by the client rather
@@ -6027,8 +6053,14 @@ const releaseSchema = selectReleaseSchema.extend({
 	createdAt: z.iso.datetime(),
 	compiledAt: z.iso.datetime().nullable()
 });
-const createReleaseBodySchema = z.object({ data: z.object({ manifest: manifestSchema }) });
-const listReleasesQuerySchema = paginationQuerySchema;
+const createReleaseBodySchema = z.object({ data: z.object({
+	manifest: manifestSchema,
+	/** The `cow.json` project this push belongs to. */
+	project: projectNameSchema
+}) });
+const listReleasesQuerySchema = paginationQuerySchema.extend({ 
+/** One project's own releases; absent lists the org's. */
+project: projectNameSchema.optional() });
 /**
 * How many live executions the cancel sweep was asked to stop, and the
 * workflow doing the stopping. The count is taken when the request lands, so
@@ -6046,10 +6078,18 @@ const cancelExecutionsSchema = z.object({
 * A deployment, plus the warnings the deploy raised: segment names in
 * triggers and destination names in spines that do not exist in the target
 * environment. They never block, because either may be created afterwards.
+* `left` is the other half of the same conversation: what the deploy did not
+* touch, because a deploy only ever adds and updates (ADR 0009).
 */
 const deploymentSchema = selectDeploymentSchema.extend({
 	createdAt: z.iso.datetime(),
 	warnings: z.array(z.string()),
+	/**
+	* Journeys this project still runs in the environment that the deployed
+	* release does not carry. A deploy never removes one, so these keep running
+	* until someone deletes them; the CLI prints them and says how.
+	*/
+	left: z.array(z.string()),
 	/** The deployed release's per-project sequence number, its human handle. */
 	releaseSeq: z.number().int()
 });
@@ -6057,7 +6097,9 @@ const createDeploymentBodySchema = z.object({ data: z.object({ releaseId: z.stri
 const listDeploymentsQuerySchema = paginationQuerySchema.extend({
 	environment: environmentSchema.optional(),
 	/** One release's own deployment history, across both environments. */
-	release: z.string().trim().min(1).max(200).optional()
+	release: z.string().trim().min(1).max(200).optional(),
+	/** One project's own deployments; absent lists the org's. */
+	project: projectNameSchema.optional()
 });
 
 //#endregion
@@ -7225,6 +7267,19 @@ async function assertCowConfig(projectDir) {
 	return parsed.data;
 }
 /**
+* Which project of the org this directory belongs to: the `project` in its
+* `cow.json`, or undefined when there is no `cow.json` here at all. The
+* undefined case is `cow pull` into an empty directory, which has no project
+* to scope by yet and reads the org's releases.
+*/
+async function configuredProject(projectDir) {
+	try {
+		return (await assertCowConfig(projectDir)).project;
+	} catch {
+		return;
+	}
+}
+/**
 * Builds the project at `projectDir`. Writes `.cow/types.d.ts` first (the
 * typecheck needs it), then the bundles and the source tarball, and
 * `.cow/build/manifest.json` last, so a failed build leaves no manifest and
@@ -8879,6 +8934,19 @@ const journeys = defineModule(defineRoute({
 		...sessionErrors,
 		...errors("not_found", "validation_failed", "malformed_request")
 	}
+}), defineRoute({
+	method: "delete",
+	path: "/v1/journeys/{key}",
+	operationId: "journeys.delete",
+	tags: ["journeys"],
+	summary: "Remove a journey from the selected environment",
+	security: SESSION_AUTH,
+	request: { params: params$5 },
+	responses: {
+		200: envelope(deletedSchema),
+		...sessionErrors,
+		...errors("not_found")
+	}
 }), defineRoute({
 	method: "post",
 	path: "/v1/journeys/{key}/dry-run",
@@ -8900,28 +8968,29 @@ const journeys = defineModule(defineRoute({
 //#endregion
 //#region ../../packages/shared/src/contract/project.ts
 /**
-* The org's project. Singular in the path on purpose: an org has exactly one
-* for now, so there is no id to put in a URL, and many projects per org is a
-* later, additive change (the `projects` row already exists so it can be).
+* The org's project. Singular in the path on purpose: a caller always means
+* one, the one its `cow.json` names, so the name is a query parameter and
+* there is no id to put in a URL. An org with a single project needs neither.
 */
 const project = defineModule(defineRoute({
 	method: "get",
 	path: "/v1/project",
 	operationId: "project.get",
 	tags: ["project"],
-	summary: "Get the organization's project",
+	summary: "Get one of the organization's projects",
 	security: RELEASE_AUTH,
+	request: { query: getProjectQuerySchema },
 	responses: {
 		200: envelope(projectSchema),
 		...sessionErrors,
-		...errors("project_missing")
+		...errors("project_missing", "validation_failed", "malformed_request")
 	}
 }), defineRoute({
 	method: "post",
 	path: "/v1/project",
 	operationId: "project.create",
 	tags: ["project"],
-	summary: "Create the organization's project",
+	summary: "Create a project in the organization",
 	security: RELEASE_AUTH,
 	request: { body: jsonBody(createProjectBodySchema) },
 	responses: {
@@ -9987,18 +10056,19 @@ const POLL_BUDGET_MS = RELEASE_COMPILE_TIMEOUT_MS + 6e4;
 const POLL_START_MS = 250;
 const POLL_MAX_MS = 2e3;
 /**
-* The org's project, created when it has none. `cow init` usually got there
-* first; a project pushed from a machine that only ever cloned the repo has
-* not, and creating it here is what makes that clone work.
+* This directory's project, created when the org has none by that name.
+* `cow init` usually got there first; a project pushed from a machine that
+* only ever cloned the repo has not, and creating it here is what makes that
+* clone work. The name is `cow.json`'s `project`.
 */
-async function ensureProject(client, projectDir) {
+async function ensureProject(client, name) {
 	try {
-		return (await client.request(contract.project["project.get"])).data;
+		return (await client.request(contract.project["project.get"], { query: { name } })).data;
 	} catch (error) {
 		if (!(error instanceof ApiError) || error.code !== "project_missing") throw error;
 	}
 	try {
-		return (await client.request(contract.project["project.create"], { body: { name: basename(projectDir) } })).data;
+		return (await client.request(contract.project["project.create"], { body: { name } })).data;
 	} catch (error) {
 		const reason = error instanceof Error ? error.message : String(error);
 		throw new Error(`This organization has no project and one could not be created (${reason}). Run \`cow init\` first.`);
@@ -10035,9 +10105,16 @@ function artifactFiles(projectDir, manifest) {
 		}
 	];
 }
-/** The most recent release, or null when the project has none yet. */
-async function latestRelease(client) {
-	return (await client.request(contract.releases["releases.list"], { query: { limit: 1 } })).data[0] ?? null;
+/**
+* This project's most recent release, or null when it has none yet. Scoped to
+* the project because a sibling repo's push must not make this one look
+* unchanged, or changed.
+*/
+async function latestRelease(client, project) {
+	return (await client.request(contract.releases["releases.list"], { query: {
+		limit: 1,
+		project
+	} })).data[0] ?? null;
 }
 /**
 * Poll until the compile settles. Backs off from a quarter second to two,
@@ -10058,10 +10135,10 @@ async function awaitCompile(client, releaseId, sleep) {
 }
 async function pushProject({ client, projectDir, force, sleep = (ms) => setTimeout$1(ms) }) {
 	const { manifest, config } = await buildProject(projectDir);
-	const project = await ensureProject(client, projectDir);
+	const project = await ensureProject(client, config.project);
 	if (project.orgId !== config.orgId) throw new Error(`cow.json is for ${config.orgId} but the credential belongs to ${project.orgId}. Log in to that organization, or use its deploy key.`);
 	const digest = manifestDigestOf(manifest);
-	const latest = await latestRelease(client);
+	const latest = await latestRelease(client, project.name);
 	if (latest && latest.manifestDigest === digest && !force) return {
 		release: latest,
 		uploaded: [],
@@ -10078,7 +10155,10 @@ async function pushProject({ client, projectDir, force, sleep = (ms) => setTimeo
 		uploaded.push(artifact.digest);
 	}
 	return {
-		release: await awaitCompile(client, (await client.request(contract.releases["releases.create"], { body: { manifest } })).data.id, sleep),
+		release: await awaitCompile(client, (await client.request(contract.releases["releases.create"], { body: {
+			manifest,
+			project: project.name
+		} })).data.id, sleep),
 		uploaded
 	};
 }
@@ -10141,6 +10221,7 @@ function deploySummary(outcome) {
 	const lines = [`${release.id} #${release.seq} deployed to ${deployment.environment}.`];
 	if (outcome.skipped) lines.unshift(outcome.skipped);
 	for (const warning of deployment.warnings) lines.push(`Warning: ${warning}`);
+	if (deployment.left.length > 0) lines.push(`Still running, not in this release: ${deployment.left.join(", ")}. Remove one with \`cow journeys delete <key> --env ${deployment.environment}\`.`);
 	return lines.join("\n");
 }
 function registerDeploy(program, clientFor, env, io) {
@@ -10542,7 +10623,8 @@ function registerInit(program, env, io) {
 		if (orgId === "") throw new Error("No organization id. Pass --org org_… or run `cow login` first.");
 		const config = cowConfigSchema.parse({
 			$schema: COW_CONFIG_SCHEMA_URL,
-			orgId
+			orgId,
+			project: name
 		});
 		const contents = {
 			"cow.json": json(config),
@@ -10648,10 +10730,11 @@ function planTools() {
 * a native tool. The tool table (tools.ts) is planned from the shared route
 * contract at startup, so the surface cannot drift from the API.
 */
-function createMcpServer({ client }) {
+async function createMcpServer({ client }) {
+	const { version } = await readCliPackage();
 	const server = new McpServer({
 		name: `${"cow"}-mcp`,
-		version: "0.0.0"
+		version
 	});
 	const request = client.request;
 	for (const tool of planTools()) server.registerTool(tool.name, {
@@ -10703,7 +10786,7 @@ function registerMcp(program, clientFor, env, io) {
 			...opts
 		});
 		if (resolveCredential(env, await readCredentials(env)).kind === "none") io.stderr("cow mcp: not logged in. Run `cow login`, or set COW_TOKEN or COW_DEPLOY_KEY.\n");
-		await createMcpServer({ client }).connect(new StdioServerTransport());
+		await (await createMcpServer({ client })).connect(new StdioServerTransport());
 	});
 }
 
@@ -10751,12 +10834,17 @@ function noGitHere(error) {
 	const failure = error;
 	return failure.code === "ENOENT" || String(failure.stderr ?? "").includes("not a git repository");
 }
-/** The release to restore: the one named, the one an environment runs, else the newest that compiled. */
-async function resolveRelease(client, releaseId, environment) {
+/**
+* The release to restore: the one named, the one an environment runs, else the
+* newest that compiled. Scoped to this directory's project, so a sibling
+* repo's release is never unpacked over this one's files.
+*/
+async function resolveRelease(client, releaseId, environment, project) {
 	if (releaseId) return (await client.request(contract.releases["releases.get"], { params: { id: releaseId } })).data;
 	if (environment) {
 		const current = (await client.request(contract.deployments["deployments.list"], { query: {
 			environment,
+			project,
 			limit: 1
 		} })).data[0];
 		if (!current) throw new Error(`Nothing has been deployed to ${environment}, so there is no release to restore. Name one with --release.`);
@@ -10766,7 +10854,8 @@ async function resolveRelease(client, releaseId, environment) {
 	do {
 		const page = await client.request(contract.releases["releases.list"], { query: {
 			limit: PAGE_SIZE,
-			cursor
+			cursor,
+			project
 		} });
 		const ready = page.data.find((release) => release.status === "ready");
 		if (ready) return ready;
@@ -10775,7 +10864,7 @@ async function resolveRelease(client, releaseId, environment) {
 	throw new Error("This organization has no release that compiled successfully. Run `cow push` first, or name one with --release.");
 }
 async function pullRelease({ client, projectDir, releaseId, environment, force }) {
-	const release = await resolveRelease(client, releaseId, environment);
+	const release = await resolveRelease(client, releaseId, environment, await configuredProject(projectDir));
 	if (!force) {
 		const dirty = await dirtyPaths(projectDir);
 		if (dirty.length > 0) throw new Error(`This working tree has uncommitted changes and \`cow pull\` would write over them:\n  ${dirty.join("\n  ")}\nCommit or stash them, or pass --force.`);
@@ -10819,9 +10908,10 @@ function registerPull(program, clientFor, env, io) {
 
 //#endregion
 //#region src/commands/rollback.ts
-async function rollbackEnvironment({ client, environment }) {
+async function rollbackEnvironment({ client, environment, project }) {
 	const [current, previous] = (await client.request(contract.deployments["deployments.list"], { query: {
 		environment,
+		project,
 		limit: 2
 	} })).data;
 	if (!current) throw new Error(`Nothing has been deployed to ${environment} yet, so there is nothing to roll back.`);
@@ -10848,7 +10938,8 @@ function registerRollback(program, clientFor, env, io) {
 		};
 		const outcome = await rollbackEnvironment({
 			client: await clientFor(merged),
-			environment: requireEnvironment(env, merged)
+			environment: requireEnvironment(env, merged),
+			project: await configuredProject(process.cwd())
 		});
 		if (merged.json === true) {
 			emit({ data: outcome.deployment }, io, true);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cowliss/cli",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "bin": {
     "cow": "./dist/index.js"