@monster-orange/den 0.2.0 → 0.2.2

package/src/shared/environment-manager/service-runner.ts

@@ -8,6 +8,7 @@
 
 import { hasRuntime, repoKind } from "../repo-kind.js";
 import { effectiveLocalCommands } from "../stacks/manifest-commands.js";
+import { manifestStackName } from "../stacks/config.js";
 import fs from "fs";
 import path from "path";
 import { readManifest } from "../manifest/read-manifest.js";
@@ -40,6 +41,7 @@ import {
   getActiveWorkspaces,
   getFocusedWorkspaceName,
   getWorkspaceByName,
+  parseAddress,
   resolveServiceSource,
   listWorkspaceServices,
 } from "./workspaces.js";
@@ -49,7 +51,12 @@ import {
   type ServiceHealthResult,
 } from "./health.js";
 import { EventEmitter } from "events";
-import type { CommandDef, ResolvedService } from "../types/index.js";
+import type {
+  CommandDef,
+  ResolvedService,
+  ServiceCatalog,
+  WorkspaceConfig,
+} from "../types/index.js";
 import type { ChildProcess } from "child_process";
 import { getStateDir } from "../paths.js";
 
@@ -658,7 +665,95 @@ export function resolveService(
     : getActiveWorkspace();
   if (!ws) return null;
   const catalog = readCatalog();
+  const listed = resolveListedService(address, ws, catalog);
+  if (listed || address.includes("/")) return listed;
+  // Not a repo or a listed address: a service key or a stack name, when it
+  // names exactly one service in the workspace.
+  const candidates = aliasCandidates(address, ws, catalog);
+  return candidates.length === 1
+    ? resolveListedService(candidates[0], ws, catalog)
+    : null;
+}
+
+type NamedWorkspace = { name: string; config: WorkspaceConfig };
+
+/**
+ * The addresses `alias` could mean in `ws`: every service whose manifest key
+ * is `alias`, and the repo of every compose stack named `alias` (a stack
+ * stands for its repo; when that repo also has a service named `alias`, the
+ * service is the one match). Sorted; empty for a `repo/service` address and
+ * for a catalog repo's name.
+ */
+function aliasCandidates(
+  alias: string,
+  ws: NamedWorkspace,
+  catalog: ServiceCatalog,
+): string[] {
+  // A repo name is never an alias, in the workspace or not.
+  if (alias.includes("/") || catalog[alias]) return [];
+  const services = new Set<string>();
+  const stackRepos = new Set<string>();
+  for (const s of listWorkspaceServices(ws.config, catalog, ws.name)) {
+    if (s.subsystem === alias) services.add(s.address);
+    const manifest = readManifest(s.repoPath);
+    if (manifest?.compose && manifestStackName(manifest, s.repoName) === alias)
+      stackRepos.add(s.repoName);
+  }
+  const withService = new Set(
+    [...services].map((a) => parseAddress(a, catalog).repoName),
+  );
+  return [
+    ...services,
+    ...[...stackRepos].filter((r) => !withService.has(r)),
+  ].sort();
+}
 
+function namedWorkspace(workspaceName?: string): NamedWorkspace | null {
+  return workspaceName
+    ? getWorkspaceByName(workspaceName)
+    : getActiveWorkspace();
+}
+
+/**
+ * What `alias` could address in the workspace (the focused one by default)
+ * when it is not a repo or a listed address: see resolveService.
+ */
+export function serviceAliasCandidates(
+  alias: string,
+  workspaceName?: string,
+): string[] {
+  const ws = namedWorkspace(workspaceName);
+  if (!ws) return [];
+  const catalog = readCatalog();
+  if (resolveListedService(alias, ws, catalog)) return [];
+  return aliasCandidates(alias, ws, catalog);
+}
+
+/**
+ * The address to use for what someone typed: an unambiguous alias becomes
+ * the service's own address; anything else is returned as is. An ambiguous
+ * alias throws, naming the candidates.
+ */
+export function canonicalServiceAddress(
+  address: string,
+  workspaceName?: string,
+): string {
+  const candidates = serviceAliasCandidates(address, workspaceName);
+  if (candidates.length > 1) {
+    const ws = namedWorkspace(workspaceName)?.name ?? "default";
+    throw new Error(
+      `"${address}" is ambiguous in workspace "${ws}": ${candidates.join(", ")}; name one of them`,
+    );
+  }
+  return candidates[0] ?? address;
+}
+
+/** resolveService for a repo name or a listed address (no aliases). */
+function resolveListedService(
+  address: string,
+  ws: NamedWorkspace,
+  catalog: ServiceCatalog,
+): ResolvedService | null {
   let resolved = resolveServiceSource(address, ws.name, ws.config, catalog);
 
   // Bare multi-service repo registered ONLY by subsystem (e.g. "shop/db" +
@@ -998,6 +1093,109 @@ export interface RunCommandResult {
   };
 }
 
+/**
+ * A service with no commands of its own is started by its repo's up
+ * (placement's repo-level rule). For `up` that is the repo's up (`address`
+ * set); any other command would reach the repo's other services too, so it
+ * points at the repo instead: a refusal, except that down succeeds (nothing
+ * of the service's own runs, and a workspace Down sends every service).
+ * Null when the rule does not apply.
+ */
+function repoStartedFallback(
+  resolved: ResolvedService,
+  command: string,
+  workspace: string | undefined,
+): { address?: string; note: string } | null {
+  const repoEntry = resolveService(resolved.repoName, workspace);
+  if (!repoEntry || repoEntry.subsystem === resolved.subsystem) return null;
+  const manifest = readManifest(resolved.repoPath);
+  if (!manifest) return null;
+  const repoCommands = effectiveLocalCommands(
+    manifest,
+    repoEntry.subsystem,
+    resolved.repoName,
+    workspace ?? "default",
+  );
+  if (!repoCommands["up"]) return null;
+  if (command === "up")
+    return {
+      address: resolved.repoName,
+      note: `${resolved.address} has no up of its own; running ${resolved.repoName}'s up, which starts it`,
+    };
+  return command === "down"
+    ? {
+        note:
+          `${resolved.address} has no down of its own; it is stopped by ${resolved.repoName}'s down. ` +
+          `Run \`${product().cli} down ${resolved.repoName}\` (that stops every service it starts).`,
+      }
+    : {
+        note:
+          `${resolved.address} has no ${command} of its own; it is started by ${resolved.repoName}'s up. ` +
+          `Run \`${product().cli} ${command} ${resolved.repoName}\` (that reaches every service it starts).`,
+      };
+}
+
+/** What a run of `command` on `address` would do, without running it. */
+export type ServiceCommandPreview =
+  | { kind: "run"; address: string }
+  | { kind: "via-repo"; address: string; note: string }
+  | { kind: "nothing"; address: string; note: string }
+  | { kind: "error"; address: string; note: string };
+
+/**
+ * The dry-run twin of runServiceCommand's command lookup: the same
+ * resolution, own-command, restart-synthesis and repo-started rules, so a
+ * dry run says what a real run does.
+ */
+export function previewServiceCommand(
+  address: string,
+  command: string,
+  workspace?: string,
+): ServiceCommandPreview {
+  const resolved = resolveService(address, workspace);
+  if (!resolved) {
+    const candidates = serviceAliasCandidates(address, workspace);
+    return {
+      kind: "error",
+      address,
+      note:
+        `service "${address}" not found in workspace "${workspace ?? "default"}"` +
+        (candidates.length > 1
+          ? `; it is ambiguous: ${candidates.join(", ")}`
+          : ""),
+    };
+  }
+  const manifest = readManifest(resolved.repoPath);
+  const own = manifest
+    ? effectiveLocalCommands(
+        manifest,
+        resolved.subsystem,
+        resolved.repoName,
+        workspace ?? "default",
+      )
+    : {};
+  if (own[command] || (command === "restart" && own["down"] && own["up"]))
+    return { kind: "run", address };
+  const viaRepo = repoStartedFallback(resolved, command, workspace);
+  if (viaRepo?.address)
+    return { kind: "via-repo", address: viaRepo.address, note: viaRepo.note };
+  if (viaRepo)
+    return command === "down"
+      ? { kind: "nothing", address, note: viaRepo.note }
+      : { kind: "error", address, note: viaRepo.note };
+  if (command === "down")
+    return {
+      kind: "nothing",
+      address,
+      note: "no down command: nothing to stop",
+    };
+  return {
+    kind: "error",
+    address,
+    note: `command "${command}" not found for service "${address}"`,
+  };
+}
+
 /**
  * Resolve and execute a service command.
  * Returns the spawned child process and whether it is a long-running (detachable) command.
@@ -1048,8 +1246,12 @@ export function runServiceCommand(
 
   const resolved = resolveService(address, workspace);
   if (!resolved) {
+    const candidates = serviceAliasCandidates(address, workspace);
     onLine(
-      `Error: service "${address}" not found in catalog or workspace "${workspace}"`,
+      `Error: service "${address}" not found in catalog or workspace "${workspace}"` +
+        (candidates.length > 1
+          ? `; it is ambiguous: ${candidates.join(", ")}`
+          : ""),
     );
     closeAsync(1);
     return dummy();
@@ -1063,7 +1265,7 @@ export function runServiceCommand(
     resolved.address,
     servicePlacement(readManifest(repoPath), subsystem, "local"),
     (e) => isProductionEnv(e) === true,
-    command === "down" ? "stop" : "start",
+    command,
   );
   if (refusal) {
     onLine(refusal);
@@ -1094,7 +1296,9 @@ export function runServiceCommand(
         workspace,
       ];
       onLine(
-        `already running (shared) — owners: [${owners.join(", ")}] at ${resolved.repoPath}`,
+        command === "restart"
+          ? `restarting the running instance (shared) — owners: [${owners.join(", ")}] at ${resolved.repoPath}`
+          : `already running (shared) — owners: [${owners.join(", ")}] at ${resolved.repoPath}`,
       );
       // restart still needs to bounce; only short-circuit pure `up`.
       if (command === "up") {
@@ -1279,6 +1483,16 @@ export function runServiceCommand(
   }
 
   if (!cmdDef) {
+    const viaRepo = repoStartedFallback(resolved, command, workspace);
+    if (viaRepo?.address) {
+      onLine(viaRepo.note);
+      return runServiceCommand({ ...options, address: viaRepo.address });
+    }
+    if (viaRepo) {
+      onLine(command === "down" ? viaRepo.note : `Error: ${viaRepo.note}`);
+      closeAsync(command === "down" ? 0 : 1);
+      return dummy();
+    }
     // Down is opctl-conventional: when no container is running AND the manifest
     // declares no down command, there is simply nothing to stop — that's a
     // successful down, not an error (keeps the ⋮ menu / workspace Down safe to

package/src/shared/manifest/placement.ts

@@ -34,6 +34,8 @@ export interface PlacementTarget {
   env: string;
   account?: string;
   url?: string;
+  /** The status codes that count as up for `url`, as declared. */
+  expect?: number | number[];
 }
 
 export interface Placement {
@@ -84,6 +86,7 @@ function targetFor(svc: ServiceManagementConfig, env: string): PlacementTarget {
     env: tEnv,
     ...(own?.account ? { account: own.account } : {}),
     ...(url ? { url } : {}),
+    ...(own?.url && own.expect !== undefined ? { expect: own.expect } : {}),
   };
 }
 
@@ -186,16 +189,25 @@ export function isProtectedRemote(p: Placement, isProduction: IsProduction) {
   return p.runs === "remote" && !!p.target && isProduction(p.target.env);
 }
 
+/** How a refusal names the command: up → "start", exec → `run "exec" on`. */
+function refusedVerb(command: string): string {
+  if (command === "up" || command === "start") return "start";
+  if (command === "down" || command === "stop") return "stop";
+  if (command === "restart") return "restart";
+  return `run "${command}" on`;
+}
+
 /**
- * Why Den must not run a command on `address`, or null. Every command on a
- * remote service is refused ("runs in dev (AWS); nothing to start here").
+ * Why Den must not run `command` on `address`, or null. Every command on a
+ * remote service is refused ("runs in dev (AWS); nothing to restart here").
  */
 export function placementRefusal(
   address: string,
   p: Placement,
   isProduction: IsProduction,
-  verb: "start" | "stop" = "start",
+  command = "up",
 ): string | null {
+  const verb = refusedVerb(command);
   if (p.runs !== "remote") return null;
   const where = p.target
     ? `${p.target.env}${p.target.account ? ` (${p.target.account})` : ""}`

package/src/shared/manifest/validate-layers.ts

@@ -15,6 +15,7 @@
  */
 
 import * as fs from "fs";
+import * as path from "path";
 import { z } from "zod";
 import type { ValidationError, ValidationResult } from "../types/index.js";
 import {
@@ -24,11 +25,14 @@ import {
   type ManifestMap,
 } from "./merge-override.js";
 import {
+  heldManifestPath,
   loadManifest,
   orphanOverrideMessage,
+  overrideSuffix,
   parseManifestText,
   type ManifestLayer,
 } from "./read-manifest.js";
+import { product } from "../product.js";
 
 /** What layered validation needs from the schema module. */
 export interface SchemaTools {
@@ -170,6 +174,31 @@ function readLayer(file: string): { value: unknown } | { error: string } {
   }
 }
 
+/**
+ * A warning for a held manifest the repo's own manifest has made redundant:
+ * the repo's file always wins, so the held one is never read.
+ */
+function redundantHeldWarning(
+  heldFile: string,
+  overrideFile: string | null,
+): ValidationError {
+  const yml = product().manifestYml;
+  const name = path.basename(heldFile);
+  const key = name.endsWith(yml) ? name.slice(0, -yml.length) : name;
+  const asOverride = path.join(
+    path.dirname(heldFile),
+    `${key}${overrideSuffix()}`,
+  );
+  return {
+    path: "",
+    file: heldFile,
+    message: `${heldFile} is not used: the repo now carries its own manifest, which always wins`,
+    suggestion: overrideFile
+      ? `delete it; ${overrideFile} already layers onto the repo's manifest`
+      : `delete it, or turn it into an override (${asOverride}) that keeps only what this distribution changes`,
+  };
+}
+
 /** Validate every manifest layer of `repoPath`, then the merged result. */
 export function validateLayers(
   tools: SchemaTools,
@@ -189,10 +218,20 @@ export function validateLayers(
   }
 
   const base = readLayer(baseFile);
-  const baseResult =
+  let baseResult =
     "error" in base
       ? failure(tools.version, baseFile, base.error)
       : withFile(tools.validate(base.value), baseFile);
+  const redundantHeld =
+    baseLayer === "repo" ? heldManifestPath(repoPath) : null;
+  if (redundantHeld)
+    baseResult = {
+      ...baseResult,
+      warnings: [
+        ...baseResult.warnings,
+        redundantHeldWarning(redundantHeld, overrideFile),
+      ],
+    };
   layers.push({ layer: baseLayer, file: baseFile, result: baseResult });
 
   if (overrideFile) {

package/src/shared/stacks/manifest-commands.ts

@@ -31,13 +31,23 @@ export function composeCommands(
   repoName: string,
   workspace: string,
 ): Record<string, CommandDef> {
-  if (!manifest.compose || !isPrimary(manifest, subsystem)) return {};
+  if (!manifest.compose) return {};
   // `docker compose up -d` returns once the containers are started, so these
   // finish on their own: never daemonize them.
   const stack = (sub: string) => ({
     cmd: `${denBin()} stack ${sub} ${manifestStackName(manifest, repoName)} -w ${workspace}`,
     detachable: false,
   });
+  // Any other manifest service names a compose service: it restarts on its
+  // own (`docker compose restart`, same container and env). Up and down stay
+  // the stack's, through the primary service.
+  if (!isPrimary(manifest, subsystem))
+    return {
+      restart: {
+        ...stack("restart"),
+        cmd: `${stack("restart").cmd} --service ${JSON.stringify(subsystem)}`,
+      },
+    };
   return {
     up: stack("up"),
     down: stack("down"),

package/src/shared/stacks/runtime.ts

@@ -266,6 +266,26 @@ export function stackDown(ctx: StackContext, s: StackConfig): void {
   }
 }
 
+/**
+ * Restart one compose service of a running stack in place (`docker compose
+ * restart`): the same container, so the same env; nothing is recreated.
+ */
+export function stackRestartService(
+  ctx: StackContext,
+  s: StackConfig,
+  service: string,
+): void {
+  const override = path.join(stackDir(ctx, s), "override.yml");
+  const args = fs.existsSync(override)
+    ? overrideArgs(ctx, s)
+    : baseArgs(ctx, s);
+  must("docker", [...args, "restart", service], {
+    cwd: repoDir(s),
+    env: composeEnv(ctx, s),
+    inherit: true,
+  });
+}
+
 export function stackPs(ctx: StackContext, s: StackConfig): string {
   return run(
     "docker",

package/src/ui/cli/flag-parser.ts

@@ -176,8 +176,9 @@ const COMMAND_FLAGS: Record<string, readonly string[]> = {
     "--force",
     "-A",
     "--app",
+    "--with-deps",
   ],
-  restart: ["-A", "--app"],
+  restart: ["-A", "--app", "-n", "--dry-run"],
   logs: [],
   setup: ["-f", "--force"],
   sync: [],