feat: allow deploying single services

Author: Shawiizz

cli/src/commands/deploy.ts

@@ -266,6 +266,7 @@ async function execute(ctx: DeployContext): Promise<void> {
   let deployFailed = false;
   let stackDeployed = false;
   let uploadPlan: UploadRollbackPlan | null = null;
+  let previousSymlink: string | null = null;
   let auditMessage = `Deploy ${ctx.deployVersion} to ${ctx.env}`;
 
   try {
@@ -277,14 +278,29 @@ async function execute(ctx: DeployContext): Promise<void> {
 
     uploadPlan = await uploadFiles(ctx);
 
-    await Promise.all([
-      ctx.releases.createRelease(ctx.stackName, ctx.deployVersion, Compose.serialize(compose), {
+    // When --only targets specific services, build the release from the local
+    // compose (preserves new services and config changes) but borrow image tags
+    // from the server release for non-targeted services so the release reflects
+    // what is actually running for those services.
+    // Falls back to the local compose as-is if no release exists yet.
+    let releaseCompose = compose;
+    if (ctx.options.only) {
+      const currentContent = await ctx.releases.getCurrentComposeContent(ctx.stackName);
+      if (currentContent) {
+        const filter = ctx.options.only.split(',').map((s: string) => s.trim());
+        releaseCompose = Compose.syncNonTargetedImageTags(compose, Compose.loadFromString(currentContent), filter);
+      }
+    }
+
+    const [releaseResult] = await Promise.all([
+      ctx.releases.createRelease(ctx.stackName, ctx.deployVersion, Compose.serialize(releaseCompose), {
         project_name: ctx.config.project_name, version: ctx.deployVersion, env: ctx.env,
         timestamp: new Date().toISOString(), epoch: Math.floor(Date.now() / 1000),
         performer: getPerformer(), branch: ctx.branchName,
       }),
       deployAccessories(ctx),
     ]);
+    previousSymlink = releaseResult.previousSymlink;
 
     await deployApp(ctx, compose);
     stackDeployed = ctx.deployApp !== false;
@@ -297,7 +313,7 @@ async function execute(ctx: DeployContext): Promise<void> {
   } catch (err) {
     deployFailed = true;
     auditMessage = `Deploy ${ctx.deployVersion} to ${ctx.env} failed: ${err instanceof Error ? err.message : String(err)}`;
-    await ctx.releases.removeRelease(ctx.stackName, ctx.deployVersion).catch(() => {});
+    await ctx.releases.removeRelease(ctx.stackName, ctx.deployVersion, previousSymlink).catch(() => {});
 
     if (uploadPlan) {
       await rollbackUploads(uploadPlan).catch((e) => printWarning(`Upload rollback failed: ${e instanceof Error ? e.message : String(e)}`));

cli/src/services/compose.ts

@@ -563,6 +563,34 @@ export function filterServices(compose: ParsedCompose, filter: string[]): Parsed
   };
 }
 
+/**
+ * Build a release compose for a partial deploy (--only).
+ *
+ * Starts from the local compose (preserves new services, config changes), then
+ * for services NOT being deployed that also exist in the server release, replaces
+ * their image tag with the one from the server so the release reflects what is
+ * actually running for those services.
+ *
+ * Services only in local  (new, not yet on server) → keep local image tag.
+ * Services only in server (removed locally)        → absent from release (correct).
+ */
+export function syncNonTargetedImageTags(
+  local: ParsedCompose,
+  server: ParsedCompose,
+  targetedServices: string[],
+): ParsedCompose {
+  const targeted = new Set(targetedServices);
+  const services = { ...local.services };
+
+  for (const [name, svc] of Object.entries(services)) {
+    if (targeted.has(name)) continue;
+    const serverImage = server.services[name]?.image as string | undefined;
+    if (serverImage) services[name] = { ...svc, image: serverImage };
+  }
+
+  return { ...local, services };
+}
+
 /**
  * Extract all external network names from a compose object.
  */

cli/src/services/release.ts

@@ -55,11 +55,15 @@ export class Release {
     version: string,
     composeYaml: string,
     metadata: ReleaseMetadata,
-  ): Promise<void> {
+  ): Promise<{ previousSymlink: string | null }> {
     const dir = this.releaseDir(stackName, version);
     const metaJson = JSON.stringify(metadata, null, 2);
     const stackDir = this.stackDir(stackName);
 
+    // Read previous symlink target before overwriting — used to restore on failure
+    const prevResult = await sshExec(this.connection, `readlink "${stackDir}/current" 2>/dev/null || echo ""`);
+    const previousSymlink = prevResult.stdout.trim() || null;
+
     await sshExec(this.connection, `mkdir -p "${dir}"`);
 
     // Write compose and metadata via stdin (no shell escaping needed)
@@ -74,6 +78,19 @@ export class Release {
     await sshExec(this.connection, `ln -sfn "${dir}" "${stackDir}/current"`);
 
     printDebug(`Release ${version} created at ${dir}`);
+    return { previousSymlink };
+  }
+
+  /**
+   * Read the compose file from the current release symlink.
+   * Returns null if no release exists yet.
+   */
+  async getCurrentComposeContent(stackName: string): Promise<string | null> {
+    const result = await sshExec(
+      this.connection,
+      `cat "${this.stackDir(stackName)}/current/docker-compose.yml" 2>/dev/null`,
+    );
+    return result.exitCode === 0 && result.stdout.trim() ? result.stdout : null;
   }
 
   /**
@@ -186,10 +203,28 @@ export class Release {
 
   /**
    * Remove a single release directory.
+   * If restoreTo is provided and the `current` symlink points to this version,
+   * restores it to the given target (or removes the symlink if restoreTo is null).
    */
-  async removeRelease(stackName: string, version: string): Promise<void> {
+  async removeRelease(stackName: string, version: string, restoreTo?: string | null): Promise<void> {
     const dir = this.releaseDir(stackName, version);
-    await sshExec(this.connection, `rm -rf "${dir}"`);
+    const stackDir = this.stackDir(stackName);
+
+    if (restoreTo !== undefined) {
+      await sshExec(
+        this.connection,
+        `currentTarget=$(readlink "${stackDir}/current" 2>/dev/null); ` +
+        `rm -rf "${dir}"; ` +
+        `if [ "$currentTarget" = "${dir}" ]; then ` +
+        (restoreTo
+          ? `ln -sfn "${restoreTo}" "${stackDir}/current"; `
+          : `rm -f "${stackDir}/current"; `) +
+        `fi`,
+      );
+    } else {
+      await sshExec(this.connection, `rm -rf "${dir}"`);
+    }
+
     printDebug(`Removed release ${version}`);
   }