@happier-dev/stack 0.1.0-preview.74.1

package/scripts/stack_archive_cmd.integration.test.mjs

@@ -0,0 +1,31 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { stat } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { runNodeCapture } from './testkit/stack_script_command_testkit.mjs';
+import { createStackArchiveFixture } from './testkit/stack_archive_command_testkit.mjs';
+
+test('hstack stack archive moves the stack and archives its referenced worktrees', async (t) => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const fixture = await createStackArchiveFixture(t, { stackName: 'exp-test', worktreeSlug: 'archived-by-stack' });
+
+  const date = '2000-01-04';
+  const nodeEnv = { ...fixture.baseEnv, PATH: '' };
+  const res = await runNodeCapture([join(rootDir, 'scripts', 'stack.mjs'), 'archive', fixture.stackName, `--date=${date}`, '--json'], {
+    cwd: rootDir,
+    env: nodeEnv,
+  });
+  assert.equal(res.code, 0, `expected stack archive exit 0\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+  const parsed = JSON.parse(res.stdout);
+  assert.equal(parsed.ok, true, `expected ok=true JSON output\n${res.stdout}`);
+
+  const archivedStackDir = join(fixture.storageDir, '.archived', date, fixture.stackName);
+  assert.equal(parsed.archivedStackDir, archivedStackDir, `expected archivedStackDir in JSON output\n${res.stdout}`);
+  await stat(join(archivedStackDir, 'env'));
+
+  const archivedWorktreeDir = join(fixture.workspaceDir, 'archive', 'worktrees', date, 'pr', 'archived-by-stack');
+  const gitStat = await stat(join(archivedWorktreeDir, '.git'));
+  assert.ok(gitStat.isDirectory(), 'expected archived worktree to be detached (standalone .git dir)');
+});

package/scripts/stack_audit_fix_light_env.test.mjs

@@ -0,0 +1,129 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { runNodeCapture } from './testkit/stack_script_command_testkit.mjs';
+
+const scriptsDir = dirname(fileURLToPath(import.meta.url));
+const rootDir = dirname(scriptsDir);
+
+async function createLightAuditFixture(t, { stackName = 'exp1', envLines }) {
+  const tmp = await mkdtemp(join(tmpdir(), 'hstack-stack-audit-light-'));
+  t.after(async () => {
+    await rm(tmp, { recursive: true, force: true });
+  });
+
+  const homeDir = join(tmp, 'home');
+  const storageDir = join(tmp, 'storage');
+  const workspaceDir = join(tmp, 'workspace');
+  const repoDir = join(workspaceDir, 'main');
+  const baseDir = join(storageDir, stackName);
+  const envPath = join(baseDir, 'env');
+
+  await mkdir(homeDir, { recursive: true });
+  await mkdir(storageDir, { recursive: true });
+  await mkdir(repoDir, { recursive: true });
+  await mkdir(baseDir, { recursive: true });
+  await writeFile(envPath, [...envLines, ''].join('\n'), 'utf-8');
+
+  return {
+    baseDir,
+    envPath,
+    env: {
+      ...process.env,
+      HAPPIER_STACK_HOME_DIR: homeDir,
+      HAPPIER_STACK_STORAGE_DIR: storageDir,
+      HAPPIER_STACK_WORKSPACE_DIR: workspaceDir,
+    },
+  };
+}
+
+async function runAuditFixPaths({ env }) {
+  return await runNodeCapture([join(rootDir, 'scripts', 'stack.mjs'), 'audit', '--fix-paths', '--json'], { cwd: rootDir, env });
+}
+
+test('hstack stack audit --fix-paths prunes legacy DATABASE_URL for light stacks and sets HAPPIER_SERVER_LIGHT_DB_DIR', async (t) => {
+  const stackName = 'exp1';
+  const fixture = await createLightAuditFixture(t, {
+    stackName,
+    envLines: (() => {
+      const dataDir = join(join(join(tmpdir(), 'unused'), stackName), 'server-light');
+      return [
+        `HAPPIER_STACK_STACK=${stackName}`,
+        `HAPPIER_STACK_SERVER_COMPONENT=happier-server-light`,
+        `HAPPIER_STACK_UI_BUILD_DIR=${join(join(tmpdir(), 'unused'), stackName, 'ui')}`,
+        `HAPPIER_STACK_CLI_HOME_DIR=${join(join(tmpdir(), 'unused'), stackName, 'cli')}`,
+        `HAPPIER_STACK_REPO_DIR=${join(tmpdir(), 'unused', 'main')}`,
+        `HAPPIER_SERVER_LIGHT_DATA_DIR=${dataDir}`,
+        `HAPPIER_SERVER_LIGHT_FILES_DIR=${join(dataDir, 'files')}`,
+        `DATABASE_URL=file:${join(dataDir, 'happier-server-light.sqlite')}`,
+      ];
+    })(),
+  });
+
+  const res = await runAuditFixPaths({ env: fixture.env });
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+
+  const raw = await readFile(fixture.envPath, 'utf-8');
+  assert.ok(raw.includes('HAPPIER_SERVER_LIGHT_DB_DIR='), `expected HAPPIER_SERVER_LIGHT_DB_DIR to be set\n${raw}`);
+  assert.ok(!raw.includes('\nDATABASE_URL='), `expected legacy DATABASE_URL to be pruned for light stacks\n${raw}`);
+});
+
+test('hstack stack audit --fix-paths normalizes mixed legacy light paths and removes DATABASE_URL', async (t) => {
+  const stackName = 'exp-mixed';
+  const fixture = await createLightAuditFixture(t, {
+    stackName,
+    envLines: [
+      `HAPPIER_STACK_STACK=${stackName}`,
+      `HAPPIER_STACK_SERVER_COMPONENT=happier-server-light`,
+      `HAPPIER_STACK_UI_BUILD_DIR=${join(fixturePathPlaceholder(), 'ui')}`,
+      `HAPPIER_STACK_CLI_HOME_DIR=${join(fixturePathPlaceholder(), 'cli')}`,
+      `HAPPIER_STACK_REPO_DIR=${join(fixturePathPlaceholder(), 'repo')}`,
+      `HAPPIER_SERVER_LIGHT_DATA_DIR=${join(fixturePathPlaceholder(), 'legacy-light')}`,
+      `HAPPIER_SERVER_LIGHT_FILES_DIR=${join(fixturePathPlaceholder(), 'legacy-light', 'files-old')}`,
+      `DATABASE_URL=file:${join(fixturePathPlaceholder(), 'legacy-light', 'legacy.sqlite')}`,
+    ],
+  });
+
+  const expectedDataDir = join(fixture.baseDir, 'server-light');
+  const expectedFilesDir = join(expectedDataDir, 'files');
+  const expectedDbDir = join(expectedDataDir, 'pglite');
+
+  const res = await runAuditFixPaths({ env: fixture.env });
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+
+  const raw = await readFile(fixture.envPath, 'utf-8');
+  assert.ok(raw.includes(`HAPPIER_SERVER_LIGHT_DATA_DIR=${expectedDataDir}`), `expected normalized data dir\n${raw}`);
+  assert.ok(raw.includes(`HAPPIER_SERVER_LIGHT_FILES_DIR=${expectedFilesDir}`), `expected normalized files dir\n${raw}`);
+  assert.ok(raw.includes(`HAPPIER_SERVER_LIGHT_DB_DIR=${expectedDbDir}`), `expected normalized db dir\n${raw}`);
+  assert.ok(!raw.includes('\nDATABASE_URL='), `expected legacy DATABASE_URL to be removed\n${raw}`);
+});
+
+test('hstack stack audit --fix-paths is idempotent for migrated light env files', async (t) => {
+  const stackName = 'exp-idempotent';
+  const fixture = await createLightAuditFixture(t, {
+    stackName,
+    envLines: [
+      `HAPPIER_STACK_STACK=${stackName}`,
+      `HAPPIER_STACK_SERVER_COMPONENT=happier-server-light`,
+      `HAPPIER_STACK_REPO_DIR=${join(fixturePathPlaceholder(), 'repo')}`,
+      `DATABASE_URL=file:${join(fixturePathPlaceholder(), 'legacy.sqlite')}`,
+    ],
+  });
+
+  const first = await runAuditFixPaths({ env: fixture.env });
+  assert.equal(first.code, 0, `expected first audit exit 0, got ${first.code}\nstdout:\n${first.stdout}\nstderr:\n${first.stderr}`);
+  const afterFirst = await readFile(fixture.envPath, 'utf-8');
+
+  const second = await runAuditFixPaths({ env: fixture.env });
+  assert.equal(second.code, 0, `expected second audit exit 0, got ${second.code}\nstdout:\n${second.stdout}\nstderr:\n${second.stderr}`);
+  const afterSecond = await readFile(fixture.envPath, 'utf-8');
+
+  assert.equal(afterSecond, afterFirst, 'expected second --fix-paths run to be idempotent');
+});
+
+function fixturePathPlaceholder() {
+  return join(tmpdir(), 'hstack-stack-audit-placeholder');
+}

package/scripts/stack_background_pinned_stack_json.test.mjs

@@ -0,0 +1,81 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { constants as osConstants, tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+function exitCodeFromSignal(signal) {
+  if (!signal) return 0;
+  const n = osConstants?.signals?.[signal];
+  return 128 + (typeof n === 'number' && Number.isFinite(n) ? n : 1);
+}
+
+function runNode(args, { cwd, env } = {}) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(process.execPath, args, { cwd, env, stdio: ['ignore', 'pipe', 'pipe'] });
+    let stdout = '';
+    let stderr = '';
+    proc.stdout.on('data', (d) => (stdout += String(d)));
+    proc.stderr.on('data', (d) => (stderr += String(d)));
+    proc.on('error', reject);
+    proc.on('exit', (code, signal) => resolve({ code: code ?? exitCodeFromSignal(signal), stdout, stderr }));
+  });
+}
+
+async function ensureMinimalMonorepo({ monoRoot }) {
+  await mkdir(join(monoRoot, 'apps', 'ui'), { recursive: true });
+  await mkdir(join(monoRoot, 'apps', 'cli'), { recursive: true });
+  await mkdir(join(monoRoot, 'apps', 'server'), { recursive: true });
+  await writeFile(join(monoRoot, 'apps', 'ui', 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(monoRoot, 'apps', 'cli', 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(monoRoot, 'apps', 'server', 'package.json'), '{}\n', 'utf-8');
+}
+
+test('hstack stack dev <pinned> --background --json does not fail fast (prints dev config)', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+
+  const tmp = await mkdtemp(join(tmpdir(), 'hstack-stack-bg-pinned-'));
+  try {
+    const storageDir = join(tmp, 'storage');
+    const monoRoot = join(tmp, 'happier');
+
+    await ensureMinimalMonorepo({ monoRoot });
+
+    await mkdir(join(storageDir, 'main'), { recursive: true });
+    const envPath = join(storageDir, 'main', 'env');
+    await writeFile(
+      envPath,
+      [
+        'HAPPIER_STACK_STACK=main',
+        `HAPPIER_STACK_REPO_DIR=${monoRoot}`,
+        'HAPPIER_STACK_SERVER_PORT=4101',
+        // Avoid external probes (tailscale) so --json stays hermetic.
+        'HAPPIER_STACK_TAILSCALE_PREFER_PUBLIC_URL=0',
+        'HAPPIER_STACK_TAILSCALE_SERVE=0',
+        '',
+      ].join('\n'),
+      'utf-8'
+    );
+
+    const env = {
+      ...process.env,
+      HAPPIER_STACK_STORAGE_DIR: storageDir,
+      HAPPIER_STACK_STACK: 'main',
+      HAPPIER_STACK_ENV_FILE: envPath,
+    };
+
+    const res = await runNode(
+      [join(rootDir, 'bin', 'hstack.mjs'), 'stack', 'dev', 'main', '--background', '--json'],
+      { cwd: rootDir, env }
+    );
+    assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstderr:\n${res.stderr}\nstdout:\n${res.stdout}`);
+    const parsed = JSON.parse(res.stdout.trim());
+    assert.equal(parsed?.mode, 'dev');
+    assert.equal(parsed?.serverPort, 4101);
+  } finally {
+    await rm(tmp, { recursive: true, force: true });
+  }
+});

package/scripts/stack_copy_auth_server_scoped.test.mjs

@@ -0,0 +1,243 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { resolveStackCredentialPaths } from './utils/auth/credentials_paths.mjs';
+
+function runNode(args, { cwd, env }) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(process.execPath, args, { cwd, env, stdio: ['ignore', 'pipe', 'pipe'] });
+    let stdout = '';
+    let stderr = '';
+    proc.stdout.on('data', (d) => (stdout += String(d)));
+    proc.stderr.on('data', (d) => (stderr += String(d)));
+    proc.on('error', reject);
+    proc.on('exit', (code, signal) => resolve({ code: code ?? (signal ? 1 : 0), signal: signal ?? null, stdout, stderr }));
+  });
+}
+
+test('hstack stack new copies server-scoped credentials from source stack', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'hstack-stack-copy-auth-server-scoped-'));
+
+  const workspaceDir = join(tmp, 'workspace');
+  const storageDir = join(tmp, 'storage');
+  const homeDir = join(tmp, 'home');
+  const sandboxDir = join(tmp, 'sandbox');
+  const sourceStack = 'seed-auth';
+  const targetStack = 'exp-copy-auth';
+  const serverPort = 4101;
+  const serverUrl = `http://127.0.0.1:${serverPort}`;
+
+  const monoRoot = join(workspaceDir, 'tmp', 'leeroy-wip');
+  await mkdir(join(monoRoot, 'apps', 'ui'), { recursive: true });
+  await mkdir(join(monoRoot, 'apps', 'cli'), { recursive: true });
+  await mkdir(join(monoRoot, 'apps', 'server', 'prisma', 'sqlite'), { recursive: true });
+  await writeFile(join(monoRoot, 'apps', 'ui', 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(monoRoot, 'apps', 'cli', 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(monoRoot, 'apps', 'server', 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(monoRoot, 'apps', 'server', 'prisma', 'schema.prisma'), 'datasource db { provider = "postgresql" }\n', 'utf-8');
+  await writeFile(join(monoRoot, 'apps', 'server', 'prisma', 'sqlite', 'schema.prisma'), 'datasource db { provider = "sqlite" }\n', 'utf-8');
+
+  const sourceCliHome = join(storageDir, sourceStack, 'cli');
+  const sourceCred = resolveStackCredentialPaths({ cliHomeDir: sourceCliHome, serverUrl });
+  await mkdir(dirname(sourceCred.serverScopedPath), { recursive: true });
+  await writeFile(sourceCred.serverScopedPath, 'seed-credential\n', 'utf-8');
+  await writeFile(join(sourceCliHome, 'settings.json'), JSON.stringify({ machineId: 'seed-machine' }) + '\n', 'utf-8');
+  await writeFile(
+    join(storageDir, sourceStack, 'env'),
+    [
+      `HAPPIER_STACK_REPO_DIR=${monoRoot}`,
+      `HAPPIER_STACK_CLI_HOME_DIR=${sourceCliHome}`,
+      `HAPPIER_STACK_SERVER_PORT=${serverPort}`,
+      '',
+    ].join('\n'),
+    'utf-8'
+  );
+
+  const env = {
+    ...process.env,
+    HAPPIER_STACK_HOME_DIR: homeDir,
+    HAPPIER_STACK_WORKSPACE_DIR: workspaceDir,
+    HAPPIER_STACK_STORAGE_DIR: storageDir,
+    HAPPIER_STACK_SANDBOX_DIR: sandboxDir,
+  };
+
+  const res = await runNode(
+    [
+      join(rootDir, 'scripts', 'stack.mjs'),
+      'new',
+      targetStack,
+      `--repo=${monoRoot}`,
+      '--server=happier-server-light',
+      `--copy-auth-from=${sourceStack}`,
+      `--port=${serverPort}`,
+      '--force-port',
+      '--json',
+    ],
+    { cwd: rootDir, env }
+  );
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+
+  const targetCliHome = join(storageDir, targetStack, 'cli');
+  const targetStableEnv = { HAPPIER_ACTIVE_SERVER_ID: `stack_${targetStack}__id_default` };
+  const targetCred = resolveStackCredentialPaths({ cliHomeDir: targetCliHome, serverUrl, env: targetStableEnv });
+  const targetCredRaw = await readFile(targetCred.serverScopedPath, 'utf-8');
+  assert.equal(targetCredRaw.trim(), 'seed-credential');
+
+  await rm(tmp, { recursive: true, force: true });
+});
+
+test('hstack stack new copy-auth prefers source server-scoped credentials over unrelated legacy access.key', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'hstack-stack-copy-auth-prefer-server-scoped-'));
+
+  const workspaceDir = join(tmp, 'workspace');
+  const storageDir = join(tmp, 'storage');
+  const homeDir = join(tmp, 'home');
+  const sandboxDir = join(tmp, 'sandbox');
+  const sourceStack = 'seed-auth';
+  const targetStack = 'exp-copy-auth';
+  const serverPort = 4101;
+  const serverUrl = `http://127.0.0.1:${serverPort}`;
+
+  const monoRoot = join(workspaceDir, 'tmp', 'leeroy-wip');
+  await mkdir(join(monoRoot, 'apps', 'ui'), { recursive: true });
+  await mkdir(join(monoRoot, 'apps', 'cli'), { recursive: true });
+  await mkdir(join(monoRoot, 'apps', 'server', 'prisma', 'sqlite'), { recursive: true });
+  await writeFile(join(monoRoot, 'apps', 'ui', 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(monoRoot, 'apps', 'cli', 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(monoRoot, 'apps', 'server', 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(monoRoot, 'apps', 'server', 'prisma', 'schema.prisma'), 'datasource db { provider = "postgresql" }\n', 'utf-8');
+  await writeFile(join(monoRoot, 'apps', 'server', 'prisma', 'sqlite', 'schema.prisma'), 'datasource db { provider = "sqlite" }\n', 'utf-8');
+
+  const sourceCliHome = join(storageDir, sourceStack, 'cli');
+  const sourceCred = resolveStackCredentialPaths({ cliHomeDir: sourceCliHome, serverUrl });
+  await mkdir(dirname(sourceCred.serverScopedPath), { recursive: true });
+  await writeFile(join(sourceCliHome, 'access.key'), 'legacy-wrong\n', 'utf-8');
+  await writeFile(sourceCred.serverScopedPath, 'server-scoped-correct\n', 'utf-8');
+  await writeFile(join(sourceCliHome, 'settings.json'), JSON.stringify({ machineId: 'seed-machine' }) + '\n', 'utf-8');
+  await writeFile(
+    join(storageDir, sourceStack, 'env'),
+    [
+      `HAPPIER_STACK_REPO_DIR=${monoRoot}`,
+      `HAPPIER_STACK_CLI_HOME_DIR=${sourceCliHome}`,
+      `HAPPIER_STACK_SERVER_PORT=${serverPort}`,
+      '',
+    ].join('\n'),
+    'utf-8'
+  );
+
+  const env = {
+    ...process.env,
+    HAPPIER_STACK_HOME_DIR: homeDir,
+    HAPPIER_STACK_WORKSPACE_DIR: workspaceDir,
+    HAPPIER_STACK_STORAGE_DIR: storageDir,
+    HAPPIER_STACK_SANDBOX_DIR: sandboxDir,
+  };
+
+  const res = await runNode(
+    [
+      join(rootDir, 'scripts', 'stack.mjs'),
+      'new',
+      targetStack,
+      `--repo=${monoRoot}`,
+      '--server=happier-server-light',
+      `--copy-auth-from=${sourceStack}`,
+      `--port=${serverPort}`,
+      '--force-port',
+      '--json',
+    ],
+    { cwd: rootDir, env }
+  );
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+
+  const targetCliHome = join(storageDir, targetStack, 'cli');
+  const targetStableEnv = { HAPPIER_ACTIVE_SERVER_ID: `stack_${targetStack}__id_default` };
+  const targetCred = resolveStackCredentialPaths({ cliHomeDir: targetCliHome, serverUrl, env: targetStableEnv });
+  const targetCredRaw = await readFile(targetCred.serverScopedPath, 'utf-8');
+  assert.equal(targetCredRaw.trim(), 'server-scoped-correct');
+
+  await rm(tmp, { recursive: true, force: true });
+});
+
+test('hstack stack new copy-auth copies stable-scope credentials from source stack', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'hstack-stack-copy-auth-stable-scope-'));
+
+  const workspaceDir = join(tmp, 'workspace');
+  const storageDir = join(tmp, 'storage');
+  const homeDir = join(tmp, 'home');
+  const sandboxDir = join(tmp, 'sandbox');
+  const sourceStack = 'seed-auth';
+  const targetStack = 'exp-copy-auth';
+  const serverPort = 4101;
+  const serverUrl = `http://127.0.0.1:${serverPort}`;
+
+  const monoRoot = join(workspaceDir, 'tmp', 'leeroy-wip');
+  await mkdir(join(monoRoot, 'apps', 'ui'), { recursive: true });
+  await mkdir(join(monoRoot, 'apps', 'cli'), { recursive: true });
+  await mkdir(join(monoRoot, 'apps', 'server', 'prisma', 'sqlite'), { recursive: true });
+  await writeFile(join(monoRoot, 'apps', 'ui', 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(monoRoot, 'apps', 'cli', 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(monoRoot, 'apps', 'server', 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(monoRoot, 'apps', 'server', 'prisma', 'schema.prisma'), 'datasource db { provider = \"postgresql\" }\n', 'utf-8');
+  await writeFile(join(monoRoot, 'apps', 'server', 'prisma', 'sqlite', 'schema.prisma'), 'datasource db { provider = \"sqlite\" }\n', 'utf-8');
+
+  const sourceCliHome = join(storageDir, sourceStack, 'cli');
+  const sourceStableEnv = { HAPPIER_ACTIVE_SERVER_ID: `stack_${sourceStack}__id_default` };
+  const sourceCredStable = resolveStackCredentialPaths({ cliHomeDir: sourceCliHome, serverUrl, env: sourceStableEnv });
+  await mkdir(dirname(sourceCredStable.serverScopedPath), { recursive: true });
+  await writeFile(join(sourceCliHome, 'access.key'), 'legacy-wrong\n', 'utf-8');
+  await writeFile(sourceCredStable.serverScopedPath, 'stable-correct\n', 'utf-8');
+  await writeFile(join(sourceCliHome, 'settings.json'), JSON.stringify({ machineId: 'seed-machine' }) + '\n', 'utf-8');
+  await writeFile(
+    join(storageDir, sourceStack, 'env'),
+    [
+      `HAPPIER_STACK_REPO_DIR=${monoRoot}`,
+      `HAPPIER_STACK_CLI_HOME_DIR=${sourceCliHome}`,
+      `HAPPIER_STACK_SERVER_PORT=${serverPort}`,
+      '',
+    ].join('\n'),
+    'utf-8'
+  );
+
+  const env = {
+    ...process.env,
+    HAPPIER_STACK_HOME_DIR: homeDir,
+    HAPPIER_STACK_WORKSPACE_DIR: workspaceDir,
+    HAPPIER_STACK_STORAGE_DIR: storageDir,
+    HAPPIER_STACK_SANDBOX_DIR: sandboxDir,
+  };
+
+  const res = await runNode(
+    [
+      join(rootDir, 'scripts', 'stack.mjs'),
+      'new',
+      targetStack,
+      `--repo=${monoRoot}`,
+      '--server=happier-server-light',
+      `--copy-auth-from=${sourceStack}`,
+      `--port=${serverPort}`,
+      '--force-port',
+      '--json',
+    ],
+    { cwd: rootDir, env }
+  );
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+
+  const targetCliHome = join(storageDir, targetStack, 'cli');
+  const targetStableEnv = { HAPPIER_ACTIVE_SERVER_ID: `stack_${targetStack}__id_default` };
+  const targetCredStable = resolveStackCredentialPaths({ cliHomeDir: targetCliHome, serverUrl, env: targetStableEnv });
+  const targetCredRaw = await readFile(targetCredStable.serverScopedPath, 'utf-8');
+  assert.equal(targetCredRaw.trim(), 'stable-correct');
+
+  await rm(tmp, { recursive: true, force: true });
+});