wip(cli): pins for the honest banner and the named compile path

Co-Authored-By: Claude <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016GiHYRmLSNWTfbX9gVQkpz

Author: claude

packages/cli/src/commands/artifact-child-env.pin.test.ts

@@ -44,8 +44,10 @@ import path from 'path';
 import ts from 'typescript';
 import {
   INTERNAL_ARTIFACT_PATH_ENV,
+  INTERNAL_CONFIG_OUTPUT_PATH_ENV,
   childEnvWithResolvedArtifact,
   readInternalArtifactPath,
+  readInternalConfigOutputPath,
 } from '../utils/internal-artifact-channel.js';
 import {
   cwdConfigJoinsBoot,
@@ -124,6 +126,28 @@ describe('the child `serve` env — OS_ARTIFACT_PATH means an operator set it',
     }
   });
 
+  it('carries where the parent compiles the cwd config only when the decision says so — and owns that variable too', () => {
+    const named = '/srv/app/build/named.json';
+    const withTarget = childEnvWithResolvedArtifact({}, { kind: 'resolved', path: named, configCompiledTo: named });
+    expect(withTarget[INTERNAL_CONFIG_OUTPUT_PATH_ENV]).toBe(named);
+    expect(readInternalConfigOutputPath(withTarget)).toBe(named);
+
+    // An inherited copy never speaks for a decision the parent did not make.
+    const parentEnv = { [INTERNAL_CONFIG_OUTPUT_PATH_ENV]: '/stale/inherited.json' };
+    for (const decision of [
+      { kind: 'resolved', path: ARTIFACT },
+      { kind: 'reference' },
+      { kind: 'empty' },
+    ] as const) {
+      const childEnv = childEnvWithResolvedArtifact(parentEnv, decision);
+      expect(
+        Object.prototype.hasOwnProperty.call(childEnv, INTERNAL_CONFIG_OUTPUT_PATH_ENV),
+        `decision ${decision.kind} declared no compile path, so the variable must be absent`,
+      ).toBe(false);
+    }
+    expect(readInternalConfigOutputPath({ [INTERNAL_CONFIG_OUTPUT_PATH_ENV]: '  ' })).toBeUndefined();
+  });
+
   it('reads a blank channel value as no decision at all', () => {
     expect(readInternalArtifactPath({})).toBeUndefined();
     expect(readInternalArtifactPath({ [INTERNAL_ARTIFACT_PATH_ENV]: '' })).toBeUndefined();
@@ -292,6 +316,27 @@ describe('cwdConfigJoinsBoot — the last rung, one predicate for both ends (#21
     }
   });
 
+  it('a config takes part when the artifact is where THIS command compiled it — a named path (os dev under OS_ARTIFACT_PATH)', () => {
+    const named = path.join(projectDir, 'build', 'named.json');
+    expect(cwdConfigJoinsBoot({
+      configExists: true,
+      configPath,
+      artifact: { kind: 'path', path: named, configCompiledTo: named },
+    })).toBe(true);
+    expect(isConfigCompiledArtifact(named, configPath, path.join(projectDir, 'build', '.', 'named.json'))).toBe(true);
+    // Declaring a compile path does not make a DIFFERENT artifact the config's own,
+    expect(cwdConfigJoinsBoot({
+      configExists: true,
+      configPath,
+      artifact: { kind: 'path', path: path.join(tmpdir(), 'elsewhere.json'), configCompiledTo: named },
+    })).toBe(false);
+    // and a URL is never a place a config was compiled to.
+    expect(isConfigCompiledArtifact('https://cdn.example.com/a.json', configPath, 'https://cdn.example.com/a.json'))
+      .toBe(false);
+    // The conventional path stays the config's own output beside a declared one.
+    expect(isConfigCompiledArtifact(ownArtifact, configPath, named)).toBe(true);
+  });
+
   it('a config does NOT take part under a reference (OS_ARTIFACT_URL)', () => {
     expect(cwdConfigJoinsBoot({ configExists: true, configPath, artifact: { kind: 'reference' } })).toBe(false);
   });

packages/cli/src/commands/serve-banner-config-row.test.ts

@@ -57,6 +57,23 @@ describe('resolveBannerConfigRow (#8978)', () => {
     })).toEqual({});
   });
 
+  it('names the compiled bundle — not the config — when a config boot served its app from one (#21501)', () => {
+    // A non-host config's standalone stack loaded dist/objectstack.json as the
+    // app bundle: the metadata served came from that file.
+    expect(resolveBannerConfigRow({
+      relativeConfig: 'objectstack.config.ts',
+      useArtifactFallback: false,
+      configBootBundle: 'dist/objectstack.json',
+    })).toEqual({ bundleSource: 'dist/objectstack.json' });
+    // A host config (or a config whose artifact was absent) loaded no bundle,
+    // so its row stays the config it booted.
+    expect(resolveBannerConfigRow({
+      relativeConfig: 'objectstack.config.ts',
+      useArtifactFallback: false,
+      configBootBundle: undefined,
+    })).toEqual({ configFile: 'objectstack.config.ts' });
+  });
+
   it('omits the row on an empty/quick-start boot (no config, no artifact)', () => {
     // `useArtifactFallback` is also set on the `OS_BOOT_EMPTY=1` quick-start
     // path — same defect, same fix: nothing was read, so nothing is named.

packages/cli/src/utils/format.config-artifact-row.test.ts

@@ -18,7 +18,7 @@ import { printServerReady, type ServerReadyOptions } from './format.js';
 const ANSI_SGR = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, 'g');
 
 describe('printServerReady Config:/Artifact: row (#8978)', () => {
-  const base: Omit<ServerReadyOptions, 'configFile' | 'artifactSource'> = {
+  const base: Omit<ServerReadyOptions, 'configFile' | 'artifactSource' | 'bundleSource'> = {
     externalBaseOrigin: 'http://localhost:3000',
     isDev: true,
     pluginCount: 1,
@@ -62,6 +62,12 @@ describe('printServerReady Config:/Artifact: row (#8978)', () => {
     expect(configLine()).toBeUndefined();
   });
 
+  it('prints a plain Artifact: row for a config boot\'s compiled bundle — no OS_ARTIFACT_URL suffix, no Config: row (#21501)', () => {
+    printServerReady({ ...base, bundleSource: 'dist/objectstack.json' });
+    expect(artifactLine()).toBe('Artifact: dist/objectstack.json');
+    expect(configLine()).toBeUndefined();
+  });
+
   it('omits BOTH rows when the caller has nothing safe to report (plain artifact-fallback path)', () => {
     // No configFile, no artifactSource — the plain `dist/objectstack.json`
     // fallback and the empty/quick-start boot. Absence beats a fabricated

packages/cli/test/artifact-flag-precedence.integration.test.ts

@@ -43,15 +43,24 @@
  *   takes). The served label alone cannot tell these apart under the source
  *   entry: it runs `NODE_ENV=development`, where the dev metadata door over
  *   the supervisor's answer serves ALPHA even with the config loaded beside it.
+ * - the honest ready banner on the bare `os start` path (no flag, the config's
+ *   own dist/ resolved, dist/ holding a different stack): a host config boots
+ *   its own module and the `serve` child's ready banner says `Config:`; a
+ *   non-host config serves its dist/ bundle and the banner says `Artifact:`
+ *   that file. No ready-banner row names a file the boot did not load.
+ * - `os dev` under a local `OS_ARTIFACT_PATH` at a named path compiles a host
+ *   config INTO that path; the file there is the config's own compiled output,
+ *   so the config still composes its plugins (read through the roster).
  * - flag over env — `dev -a` under an `OS_ARTIFACT_URL` naming the other one.
  * - the documented first-project path — `start --artifact
- *   ./dist/objectstack.json` beside its config — is the one boot a config
- *   still joins (that file is the config's OWN compiled output), and it serves
+ *   ./dist/objectstack.json` beside its config — is a boot the config still
+ *   joins (that file is the config's OWN compiled output), and it serves
  *   that file even under an exported `OS_ARTIFACT_PATH` naming another: the
  *   config boot is handed the supervisor's answer instead of re-deriving it.
  *
- * Each case also checks the supervisor's `Artifact:` row named the file that
- * was served: the card's rule is never to print one artifact and serve another.
+ * The named-artifact cases also check the supervisor's `Artifact:` row named the
+ * file that was served: the card's rule is never to print one artifact and
+ * serve another.
  *
  * ## Spawn shape
  *
@@ -83,8 +92,8 @@ import { defineStackSourceFromLiteral, linkSpec, writeDefineStackConfig } from '
 /** The banner's tail — every row above it has printed. */
 const READY = /Press Ctrl\+C to stop/;
 const BOOT_TIMEOUT_MS = 180_000;
-/** Eight boots, one after another, each well under its own budget when healthy. */
-const ALL_BOOTS_TIMEOUT_MS = 8 * (BOOT_TIMEOUT_MS + 30_000);
+/** Ten boots, one after another, each well under its own budget when healthy. */
+const ALL_BOOTS_TIMEOUT_MS = 10 * (BOOT_TIMEOUT_MS + 30_000);
 /** The host config's plugin — on the boot's plugin roster iff the config was loaded. */
 const HOST_MARKER = 'com.example.fx.host-marker';
 
@@ -218,6 +227,19 @@ function artifactRow(output: string): string | undefined {
   return /^.*\bArtifact: [^\n]*$/m.exec(output)?.[0];
 }
 
+/**
+ * The `serve` child's READY banner row — `Config:` or `Artifact:` — read only
+ * after `Server is ready`, so neither the supervisor's pre-boot rows nor the
+ * child's boot diagnostics can answer for it. `undefined` when the banner
+ * carries neither (an artifact-fallback boot omits the row by design).
+ */
+function readyRow(output: string): { label: 'Config' | 'Artifact'; value: string } | undefined {
+  const at = output.search(/Server is ready/);
+  if (at < 0) return undefined;
+  const m = /^[ \t]+(Config|Artifact):[ \t]+([^\n]*)$/m.exec(output.slice(at));
+  return m ? { label: m[1] as 'Config' | 'Artifact', value: m[2].trim() } : undefined;
+}
+
 interface Reading {
   served?: string;
   status?: number;
@@ -314,10 +336,10 @@ beforeAll(async () => {
   readings.leg2NoDist = await measure([...startArgs(join(root, 'h-leg2-nodist')), '--artifact', alpha], configOnly);
   readings.leg2Control = await measure([...startArgs(join(root, 'h-leg2-ctl')), '--artifact', alpha], noConfig);
   readings.hostConfig = await measure([...startArgs(join(root, 'h-host')), '--artifact', alpha], hostConfig);
-  readings.hostConfigOwn = await measure(
-    [...startArgs(join(root, 'h-host-own')), '--artifact', './dist/objectstack.json'],
-    hostConfig,
-  );
+  // The bare `os start` path beside a config: no flag, the config's own dist/
+  // resolved. dist/ holds BRAVO, a DIFFERENT stack from either config.
+  readings.hostConfigOwn = await measure([...startArgs(join(root, 'h-host-own'))], hostConfig);
+  readings.bareNonHost = await measure([...startArgs(join(root, 'h-bare-nonhost'))], withConfig);
   readings.flagOverEnv = await measure([...devArgs, '-a', alpha], bare, {
     OS_ARTIFACT_URL: pathToFileURL(bravo).href,
   });
@@ -326,6 +348,10 @@ beforeAll(async () => {
     withConfig,
     { OS_ARTIFACT_PATH: alpha },
   );
+  // `os dev` under a local OS_ARTIFACT_PATH at a NON-default path compiles the
+  // host config INTO it (it does not exist yet), so that file is the config's
+  // own compiled output and the config must still compose its plugins.
+  readings.devNamedPathHost = await measure([...devArgs], hostConfig, { OS_ARTIFACT_PATH: 'build/named.json' });
 }, ALL_BOOTS_TIMEOUT_MS);
 
 afterAll(async () => {
@@ -374,10 +400,30 @@ describe('#21501 — the named artifact is the served stack, beside a config or
     expect(r.output).not.toContain(HOST_MARKER);
   });
 
-  it('a HOST config still boots ITSELF when the artifact is its own compiled output (the marker\'s positive control)', () => {
+  it('a bare `os start` beside a HOST config with a differing dist/ boots the config itself — and its ready banner says `Config:`', () => {
+    // Also the roster marker's positive control: the config's own compiled
+    // output is the one artifact a config still joins.
     const r = reading('hostConfigOwn');
     expect(r.status).toBe(200);
     expect(r.output).toContain(HOST_MARKER);
+    // The served label is not asserted here: under the source entry
+    // (`NODE_ENV=development`) the dev metadata door over dist/ composes beside
+    // the host module — see the header.
+    expect(readyRow(r.output ?? '')).toEqual({ label: 'Config', value: 'objectstack.config.ts' });
+  });
+
+  it('a bare `os start` beside a NON-host config serves its dist/ bundle — and its ready banner says `Artifact:` that file', () => {
+    const r = reading('bareNonHost');
+    expect(r.status).toBe(200);
+    expect(r.served).toBe('Widget BRAVO');
+    expect(readyRow(r.output ?? '')).toEqual({ label: 'Artifact', value: 'dist/objectstack.json' });
+  });
+
+  it('`os dev` under OS_ARTIFACT_PATH at a named path compiles a HOST config there, and the config still composes its plugins', () => {
+    const r = reading('devNamedPathHost');
+    expect(r.status).toBe(200);
+    expect(r.artifactRow).toContain('build/named.json');
+    expect(r.output).toContain(HOST_MARKER);
   });
 
   it('flag over env: `os dev -a ALPHA` under OS_ARTIFACT_URL naming BRAVO serves ALPHA', () => {