happy-stacks 0.0.0 → 0.1.2

package/extras/swiftbar/pnpm-term.sh

@@ -1,125 +1,5 @@
 #!/bin/bash
 set -euo pipefail
 
-# Open preferred terminal and run a happys command.
-#
-# Preference order follows wt shell semantics:
-# - HAPPY_LOCAL_WT_TERMINAL=ghostty|iterm|terminal|current
-#   (also accepts "auto" which tries ghostty->iterm->terminal->current)
-#
-# Notes:
-# - iTerm / Terminal: we run the command automatically via AppleScript.
-# - Ghostty: best-effort; if we can't run the command, we open Ghostty in the dir and copy the command to clipboard.
-
-HAPPY_STACKS_HOME_DIR="${HAPPY_STACKS_HOME_DIR:-$HOME/.happy-stacks}"
-HAPPY_LOCAL_DIR="${HAPPY_LOCAL_DIR:-$HAPPY_STACKS_HOME_DIR}"
-
-WORKDIR="${HAPPY_STACKS_WORKSPACE_DIR:-$HAPPY_STACKS_HOME_DIR/workspace}"
-if [[ ! -d "$WORKDIR" ]]; then
-  WORKDIR="$HOME"
-fi
-
-PNPM_SH="$HAPPY_LOCAL_DIR/extras/swiftbar/pnpm.sh"
-if [[ ! -x "$PNPM_SH" ]]; then
-  echo "missing happys wrapper: $PNPM_SH" >&2
-  exit 1
-fi
-
-pref_raw="$(echo "${HAPPY_STACKS_WT_TERMINAL:-${HAPPY_LOCAL_WT_TERMINAL:-auto}}" | tr '[:upper:]' '[:lower:]')"
-pref="$pref_raw"
-if [[ "$pref" == "" ]]; then pref="auto"; fi
-
-cmd=( "$PNPM_SH" "$@" )
-
-escape_for_osascript_string() {
-  # Escape for inclusion inside an AppleScript string literal.
-  # (We generate: write text "<cmd>")
-  local s="$1"
-  s="${s//\\/\\\\}"
-  s="${s//\"/\\\"}"
-  echo "$s"
-}
-
-shell_cmd() {
-  # Build a zsh command that cds and runs happys (via wrapper), leaving the shell open.
-  local joined=""
-  local q
-  joined="cd \"${WORKDIR//\"/\\\"}\"; "
-  for q in "${cmd[@]}"; do
-    # Basic shell quoting
-    if [[ "$q" =~ [[:space:]\\"\'\$\`\!\&\|\;\<\>\(\)\[\]\{\}] ]]; then
-      joined+="'${q//\'/\'\\\'\'}' "
-    else
-      joined+="$q "
-    fi
-  done
-  joined+="; echo; echo \"[happy-stacks] done\"; exec /bin/zsh -i"
-  echo "$joined"
-}
-
-run_iterm() {
-  if ! command -v osascript >/dev/null 2>&1; then
-    return 1
-  fi
-  local s
-  s="$(shell_cmd)"
-  s="$(escape_for_osascript_string "$s")"
-  osascript \
-    -e 'tell application "iTerm" to activate' \
-    -e 'tell application "iTerm" to create window with default profile' \
-    -e "tell application \"iTerm\" to tell current session of current window to write text \"${s}\"" >/dev/null
-}
-
-run_terminal_app() {
-  if ! command -v osascript >/dev/null 2>&1; then
-    return 1
-  fi
-  local s
-  s="$(shell_cmd)"
-  # Terminal.app uses do script.
-  s="$(escape_for_osascript_string "$s")"
-  osascript \
-    -e 'tell application "Terminal" to activate' \
-    -e "tell application \"Terminal\" to do script \"${s}\"" >/dev/null
-}
-
-run_ghostty() {
-  if ! command -v ghostty >/dev/null 2>&1; then
-    return 1
-  fi
-
-  # Best-effort: try to run the command. If ghostty doesn't support -e on this system,
-  # fall back to opening the dir and copying the command.
-  local s
-  s="$(shell_cmd)"
-  if ghostty --working-directory "$WORKDIR" -e /bin/zsh -lc "$s" >/dev/null 2>&1; then
-    return 0
-  fi
-
-  # Fallback: open in dir and copy command for manual paste.
-  echo -n "$s" | pbcopy 2>/dev/null || true
-  ghostty --working-directory "$WORKDIR" >/dev/null 2>&1 || true
-  return 0
-}
-
-try_one() {
-  local t="$1"
-  case "$t" in
-    ghostty) run_ghostty ;;
-    iterm) run_iterm ;;
-    terminal) run_terminal_app ;;
-    current) ( cd "$WORKDIR"; exec "${cmd[@]}" ) ;;
-    *) return 1 ;;
-  esac
-}
-
-if [[ "$pref" == "auto" ]]; then
-  for t in ghostty iterm terminal current; do
-    if try_one "$t"; then
-      exit 0
-    fi
-  done
-  exit 1
-fi
-
-try_one "$pref"
+# Back-compat wrapper. Use `happys-term.sh` for new installs.
+exec "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/happys-term.sh" "$@"

package/extras/swiftbar/pnpm.sh

@@ -2,20 +2,9 @@
 set -euo pipefail
 
 # Back-compat wrapper for SwiftBar menu actions.
-# Historically this executed `pnpm` in the cloned repo; it now executes `happys`.
+# Historically this executed `pnpm`; now it delegates to `happys.sh`.
 
 HAPPY_STACKS_HOME_DIR="${HAPPY_STACKS_HOME_DIR:-$HOME/.happy-stacks}"
 HAPPY_LOCAL_DIR="${HAPPY_LOCAL_DIR:-$HAPPY_STACKS_HOME_DIR}"
 
-HAPPYS_BIN="$HAPPY_LOCAL_DIR/bin/happys"
-if [[ ! -x "$HAPPYS_BIN" ]]; then
-  HAPPYS_BIN="$(command -v happys 2>/dev/null || true)"
-fi
-
-if [[ -z "${HAPPYS_BIN:-}" ]]; then
-  echo "happys not found (run: npx happy-stacks init, or npm i -g happy-stacks)" >&2
-  exit 1
-fi
-
-exec "$HAPPYS_BIN" "$@"
-
+exec "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/happys.sh" "$@"

package/extras/swiftbar/set-server-flavor.sh

@@ -27,31 +27,31 @@ fi
 HAPPY_STACKS_HOME_DIR="${HAPPY_STACKS_HOME_DIR:-$HOME/.happy-stacks}"
 HAPPY_LOCAL_DIR="${HAPPY_LOCAL_DIR:-$HAPPY_STACKS_HOME_DIR}"
 
-PNPM_BIN="$HAPPY_LOCAL_DIR/extras/swiftbar/pnpm.sh"
-if [[ ! -x "$PNPM_BIN" ]]; then
+HAPPYS_BIN="$HAPPY_LOCAL_DIR/extras/swiftbar/happys.sh"
+if [[ ! -x "$HAPPYS_BIN" ]]; then
   echo "happys wrapper not found (run: happys menubar install)" >&2
   exit 1
 fi
 
 restart_main_service_best_effort() {
-  "$PNPM_BIN" service:restart >/dev/null 2>&1 || true
+  "$HAPPYS_BIN" service:restart >/dev/null 2>&1 || true
   # If the installed LaunchAgent is still legacy/baked, reinstall so it persists only env-file pointer.
-  "$PNPM_BIN" service:install >/dev/null 2>&1 || true
+  "$HAPPYS_BIN" service:install >/dev/null 2>&1 || true
 }
 
 restart_stack_service_best_effort() {
   local name="$1"
-  "$PNPM_BIN" stack service:restart "$name" >/dev/null 2>&1 || true
-  "$PNPM_BIN" stack service:install "$name" >/dev/null 2>&1 || true
+  "$HAPPYS_BIN" stack service:restart "$name" >/dev/null 2>&1 || true
+  "$HAPPYS_BIN" stack service:install "$name" >/dev/null 2>&1 || true
 }
 
 if [[ "$STACK" == "main" ]]; then
-  "$PNPM_BIN" srv -- use "$FLAVOR"
+  "$HAPPYS_BIN" srv -- use "$FLAVOR"
   restart_main_service_best_effort
   echo "ok: main -> $FLAVOR"
   exit 0
 fi
 
-"$PNPM_BIN" stack srv "$STACK" -- use "$FLAVOR"
+"$HAPPYS_BIN" stack srv "$STACK" -- use "$FLAVOR"
 restart_stack_service_best_effort "$STACK"
 echo "ok: $STACK -> $FLAVOR"

package/extras/swiftbar/wt-pr.sh

@@ -20,7 +20,7 @@ STACK_NAME="${2:-}"
 HAPPY_STACKS_HOME_DIR="${HAPPY_STACKS_HOME_DIR:-$HOME/.happy-stacks}"
 HAPPY_LOCAL_DIR="${HAPPY_LOCAL_DIR:-$HAPPY_STACKS_HOME_DIR}"
 
-HAPPYS="$HAPPY_LOCAL_DIR/extras/swiftbar/pnpm.sh"
+HAPPYS="$HAPPY_LOCAL_DIR/extras/swiftbar/happys.sh"
 if [[ ! -x "$HAPPYS" ]]; then
   HAPPYS="$(command -v happys 2>/dev/null || true)"
 fi

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "happy-stacks",
   "type": "module",
-  "version": "0.0.0",
+  "version": "0.1.2",
   "packageManager": "pnpm@10.18.3",
   "bin": {
     "happys": "./bin/happys.mjs",

package/scripts/auth.mjs

@@ -1,12 +1,16 @@
 import './utils/env.mjs';
 import { parseArgs } from './utils/args.mjs';
 import { printResult, wantsHelp, wantsJson } from './utils/cli.mjs';
-import { getComponentDir, getDefaultAutostartPaths, getRootDir, getStackName } from './utils/paths.mjs';
+import { getComponentDir, getDefaultAutostartPaths, getRootDir, getStackName, resolveStackEnvPath } from './utils/paths.mjs';
 import { resolvePublicServerUrl } from './tailscale.mjs';
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { spawn } from 'node:child_process';
+import { chmod, copyFile, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+
+import { parseDotenv } from './utils/dotenv.mjs';
 
 function getInternalServerUrl() {
   const portRaw = (process.env.HAPPY_LOCAL_SERVER_PORT ?? process.env.HAPPY_STACKS_SERVER_PORT ?? '').trim();
@@ -19,6 +23,104 @@ function expandTilde(p) {
   return p.replace(/^~(?=\/)/, homedir());
 }
 
+async function ensureDir(p) {
+  await mkdir(p, { recursive: true });
+}
+
+async function readTextIfExists(path) {
+  try {
+    if (!existsSync(path)) return null;
+    const raw = await readFile(path, 'utf-8');
+    const t = raw.trim();
+    return t ? t : null;
+  } catch {
+    return null;
+  }
+}
+
+async function writeSecretFileIfMissing({ path, secret }) {
+  if (existsSync(path)) return false;
+  await ensureDir(dirname(path));
+  await writeFile(path, secret, { encoding: 'utf-8', mode: 0o600 });
+  return true;
+}
+
+async function copyFileIfMissing({ from, to, mode }) {
+  if (existsSync(to)) return false;
+  if (!existsSync(from)) return false;
+  await ensureDir(dirname(to));
+  await copyFile(from, to);
+  if (mode) {
+    await chmod(to, mode).catch(() => {});
+  }
+  return true;
+}
+
+function parseEnvToObject(raw) {
+  const parsed = parseDotenv(raw);
+  return Object.fromEntries(parsed.entries());
+}
+
+function getStackDir(stackName) {
+  return resolveStackEnvPath(stackName).baseDir;
+}
+
+function getStackEnvPath(stackName) {
+  return resolveStackEnvPath(stackName).envPath;
+}
+
+function stackExistsSync(stackName) {
+  if (stackName === 'main') return true;
+  const envPath = getStackEnvPath(stackName);
+  return existsSync(envPath);
+}
+
+function getCliHomeDirFromEnvOrDefault({ stackBaseDir, env }) {
+  const fromEnv = (env.HAPPY_STACKS_CLI_HOME_DIR ?? env.HAPPY_LOCAL_CLI_HOME_DIR ?? '').trim();
+  return fromEnv || join(stackBaseDir, 'cli');
+}
+
+function getServerLightDataDirFromEnvOrDefault({ stackBaseDir, env }) {
+  const fromEnv = (env.HAPPY_SERVER_LIGHT_DATA_DIR ?? '').trim();
+  return fromEnv || join(stackBaseDir, 'server-light');
+}
+
+async function resolveHandyMasterSecretFromStack({ stackName, requireStackExists }) {
+  if (requireStackExists && !stackExistsSync(stackName)) {
+    throw new Error(`[auth] cannot copy auth: source stack "${stackName}" does not exist`);
+  }
+
+  const sourceBaseDir = getStackDir(stackName);
+  const sourceEnvPath = getStackEnvPath(stackName);
+  const raw = await readTextIfExists(sourceEnvPath);
+  const env = raw ? parseEnvToObject(raw) : {};
+
+  const inline = (env.HANDY_MASTER_SECRET ?? '').trim();
+  if (inline) {
+    return { secret: inline, source: `${sourceEnvPath} (HANDY_MASTER_SECRET)` };
+  }
+
+  const secretFile = (env.HAPPY_STACKS_HANDY_MASTER_SECRET_FILE ?? '').trim();
+  if (secretFile) {
+    const secret = await readTextIfExists(secretFile);
+    if (secret) return { secret, source: secretFile };
+  }
+
+  const dataDir = getServerLightDataDirFromEnvOrDefault({ stackBaseDir: sourceBaseDir, env });
+  const secretPath = join(dataDir, 'handy-master-secret.txt');
+  const secret = await readTextIfExists(secretPath);
+  if (secret) return { secret, source: secretPath };
+
+  // Last-resort legacy: if main has never been migrated to stack dirs.
+  if (stackName === 'main') {
+    const legacy = join(homedir(), '.happy', 'server-light', 'handy-master-secret.txt');
+    const legacySecret = await readTextIfExists(legacy);
+    if (legacySecret) return { secret: legacySecret, source: legacy };
+  }
+
+  return { secret: null, source: null };
+}
+
 function resolveCliHomeDir() {
   const fromEnv = (process.env.HAPPY_LOCAL_CLI_HOME_DIR ?? process.env.HAPPY_STACKS_CLI_HOME_DIR ?? '').trim();
   if (fromEnv) {
@@ -94,6 +196,261 @@ function authLoginSuggestion(stackName) {
   return stackName === 'main' ? 'happys auth login' : `happys stack auth ${stackName} login`;
 }
 
+function authCopyFromMainSuggestion(stackName) {
+  if (stackName === 'main') return null;
+  return `happys stack auth ${stackName} copy-from main`;
+}
+
+function resolveServerComponentForCurrentStack() {
+  return (
+    (process.env.HAPPY_STACKS_SERVER_COMPONENT ?? process.env.HAPPY_LOCAL_SERVER_COMPONENT ?? 'happy-server-light').trim() ||
+    'happy-server-light'
+  );
+}
+
+async function runNodeCapture({ cwd, env, args, stdin }) {
+  return await new Promise((resolvePromise, rejectPromise) => {
+    const child = spawn(process.execPath, args, {
+      cwd,
+      env,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', (d) => {
+      stdout += String(d);
+    });
+    child.stderr.on('data', (d) => {
+      stderr += String(d);
+    });
+    child.on('error', (err) => rejectPromise(err));
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolvePromise({ stdout, stderr });
+        return;
+      }
+      rejectPromise(new Error(`node exited with ${code}${stderr.trim() ? `: ${stderr.trim()}` : ''}`));
+    });
+    if (stdin != null) {
+      child.stdin.write(String(stdin));
+    }
+    child.stdin.end();
+  });
+}
+
+function resolveServerComponentFromEnv(env) {
+  const v = (env.HAPPY_STACKS_SERVER_COMPONENT ?? env.HAPPY_LOCAL_SERVER_COMPONENT ?? 'happy-server-light').trim() || 'happy-server-light';
+  return v === 'happy-server' ? 'happy-server' : 'happy-server-light';
+}
+
+function resolveDatabaseUrlFromEnvOrThrow(env, { label }) {
+  const v = (env.DATABASE_URL ?? '').trim();
+  if (!v) throw new Error(`[auth] missing DATABASE_URL for ${label}`);
+  return v;
+}
+
+function resolveServerComponentDir({ rootDir, serverComponent }) {
+  return getComponentDir(rootDir, serverComponent === 'happy-server' ? 'happy-server' : 'happy-server-light');
+}
+
+async function seedAccountsFromSourceDbToTargetDb({
+  rootDir,
+  fromStackName,
+  fromServerComponent,
+  fromDatabaseUrl,
+  targetStackName,
+  targetServerComponent,
+  targetDatabaseUrl,
+}) {
+  const sourceCwd = resolveServerComponentDir({ rootDir, serverComponent: fromServerComponent });
+  const targetCwd = resolveServerComponentDir({ rootDir, serverComponent: targetServerComponent });
+
+  const listScript = `
+process.on('uncaughtException', (e) => {
+  console.error(e instanceof Error ? e.message : String(e));
+  process.exit(1);
+});
+process.on('unhandledRejection', (e) => {
+  console.error(e instanceof Error ? e.message : String(e));
+  process.exit(1);
+});
+import { PrismaClient } from '@prisma/client';
+const db = new PrismaClient();
+try {
+  const accounts = await db.account.findMany({ select: { id: true, publicKey: true } });
+  console.log(JSON.stringify(accounts));
+} finally {
+  await db.$disconnect();
+}
+`.trim();
+
+  const insertScript = `
+process.on('uncaughtException', (e) => {
+  console.error(e instanceof Error ? e.message : String(e));
+  process.exit(1);
+});
+process.on('unhandledRejection', (e) => {
+  console.error(e instanceof Error ? e.message : String(e));
+  process.exit(1);
+});
+import { PrismaClient } from '@prisma/client';
+import fs from 'node:fs';
+const raw = fs.readFileSync(0, 'utf8').trim();
+const accounts = raw ? JSON.parse(raw) : [];
+const db = new PrismaClient();
+try {
+  let insertedCount = 0;
+  for (const a of accounts) {
+    // eslint-disable-next-line no-await-in-loop
+    try {
+      await db.account.create({ data: { id: a.id, publicKey: a.publicKey } });
+      insertedCount += 1;
+    } catch (e) {
+      // Prisma unique constraint violation
+      if (e && typeof e === 'object' && 'code' in e && e.code === 'P2002') {
+        continue;
+      }
+      throw e;
+    }
+  }
+  console.log(JSON.stringify({ sourceCount: accounts.length, insertedCount }));
+} finally {
+  await db.$disconnect();
+}
+`.trim();
+
+  const { stdout: srcOut } = await runNodeCapture({
+    cwd: sourceCwd,
+    env: { ...process.env, DATABASE_URL: fromDatabaseUrl },
+    args: ['--input-type=module', '-e', listScript],
+  });
+  const accounts = srcOut.trim() ? JSON.parse(srcOut.trim()) : [];
+
+  const { stdout: insOut } = await runNodeCapture({
+    cwd: targetCwd,
+    env: { ...process.env, DATABASE_URL: targetDatabaseUrl },
+    args: ['--input-type=module', '-e', insertScript],
+    stdin: JSON.stringify(accounts),
+  });
+  const res = insOut.trim() ? JSON.parse(insOut.trim()) : { sourceCount: accounts.length, insertedCount: 0 };
+
+  return {
+    ok: true,
+    fromStackName,
+    targetStackName,
+    sourceCount: Number(res.sourceCount ?? accounts.length) || 0,
+    insertedCount: Number(res.insertedCount ?? 0) || 0,
+  };
+}
+
+async function cmdCopyFrom({ argv, json }) {
+  const rootDir = getRootDir(import.meta.url);
+  const stackName = getStackName();
+  if (stackName === 'main') {
+    throw new Error('[auth] copy-from is intended for stack-scoped usage (e.g. happys stack auth <name> copy-from main)');
+  }
+
+  const positionals = argv.filter((a) => !a.startsWith('--'));
+  const fromStackName = (positionals[1] ?? '').trim();
+  if (!fromStackName) {
+    throw new Error('[auth] usage: happys stack auth <name> copy-from <sourceStack> [--json]');
+  }
+
+  const serverComponent = resolveServerComponentForCurrentStack();
+  const targetBaseDir = getDefaultAutostartPaths().baseDir;
+  const targetCli = resolveCliHomeDir();
+  const targetServerLightDataDir =
+    (process.env.HAPPY_SERVER_LIGHT_DATA_DIR ?? '').trim() || join(targetBaseDir, 'server-light');
+  const targetSecretFile =
+    (process.env.HAPPY_STACKS_HANDY_MASTER_SECRET_FILE ?? '').trim() || join(targetBaseDir, 'happy-server', 'handy-master-secret.txt');
+
+  const { secret, source } = await resolveHandyMasterSecretFromStack({ stackName: fromStackName, requireStackExists: true });
+
+  const copied = {
+    secret: false,
+    accessKey: false,
+    settings: false,
+    db: false,
+    dbAccounts: null,
+    dbError: null,
+    sourceStack: fromStackName,
+    stackName,
+  };
+
+  if (secret) {
+    if (serverComponent === 'happy-server-light') {
+      copied.secret = await writeSecretFileIfMissing({ path: join(targetServerLightDataDir, 'handy-master-secret.txt'), secret });
+    } else if (serverComponent === 'happy-server') {
+      copied.secret = await writeSecretFileIfMissing({ path: targetSecretFile, secret });
+    }
+  }
+
+  const sourceBaseDir = getStackDir(fromStackName);
+  const sourceEnvRaw = await readTextIfExists(getStackEnvPath(fromStackName));
+  const sourceEnv = sourceEnvRaw ? parseEnvToObject(sourceEnvRaw) : {};
+  const sourceCli = getCliHomeDirFromEnvOrDefault({ stackBaseDir: sourceBaseDir, env: sourceEnv });
+
+  copied.accessKey = await copyFileIfMissing({
+    from: join(sourceCli, 'access.key'),
+    to: join(targetCli, 'access.key'),
+    mode: 0o600,
+  });
+  copied.settings = await copyFileIfMissing({
+    from: join(sourceCli, 'settings.json'),
+    to: join(targetCli, 'settings.json'),
+    mode: 0o600,
+  });
+
+  // Best-effort DB seeding: copy Account rows from source stack DB to target stack DB.
+  // This avoids FK failures (e.g., Prisma P2003) when the target DB is fresh but the copied token
+  // refers to an account ID that does not exist there yet.
+  try {
+    const fromServerComponent = resolveServerComponentFromEnv(sourceEnv);
+    const fromDatabaseUrl = resolveDatabaseUrlFromEnvOrThrow(sourceEnv, { label: `source stack "${fromStackName}"` });
+    const targetEnv = process.env;
+    const targetServerComponent = resolveServerComponentFromEnv(targetEnv);
+    const targetDatabaseUrl = resolveDatabaseUrlFromEnvOrThrow(targetEnv, { label: `target stack "${stackName}"` });
+
+    const seeded = await seedAccountsFromSourceDbToTargetDb({
+      rootDir,
+      fromStackName,
+      fromServerComponent,
+      fromDatabaseUrl,
+      targetStackName: stackName,
+      targetServerComponent,
+      targetDatabaseUrl,
+    });
+    copied.dbAccounts = { sourceCount: seeded.sourceCount, insertedCount: seeded.insertedCount };
+    copied.db = true;
+  } catch (err) {
+    copied.db = false;
+    copied.dbAccounts = null;
+    copied.dbError = err instanceof Error ? err.message : String(err);
+    if (!json) {
+      console.warn(`[auth] db seed skipped: ${copied.dbError}`);
+    }
+  }
+
+  if (json) {
+    printResult({ json, data: { ok: true, copied } });
+    return;
+  }
+
+  const any = copied.secret || copied.accessKey || copied.settings || copied.db;
+  if (!any) {
+    console.log(`[auth] nothing to copy (target already has auth files)`);
+    return;
+  }
+
+  console.log(`[auth] copied auth from "${fromStackName}" into "${stackName}" (no re-login needed)`);
+  if (copied.secret) console.log(`  - master secret: copied (${source || 'unknown source'})`);
+  if (copied.dbAccounts) {
+    console.log(`  - db: seeded Account rows (inserted=${copied.dbAccounts.insertedCount}/${copied.dbAccounts.sourceCount})`);
+  }
+  if (copied.accessKey) console.log(`  - cli: copied access.key`);
+  if (copied.settings) console.log(`  - cli: copied settings.json`);
+}
+
 async function cmdStatus({ json }) {
   const rootDir = getRootDir(import.meta.url);
   const stackName = getStackName();
@@ -162,11 +519,20 @@ async function cmdStatus({ json }) {
   console.log(authLine);
   if (!auth.ok) {
     console.log(`  ↪ run: ${authLoginSuggestion(stackName)}`);
+    const copyFromMain = authCopyFromMainSuggestion(stackName);
+    if (copyFromMain) {
+      console.log(`  ↪ or (recommended if main is already logged in): ${copyFromMain}`);
+    }
   }
   console.log(daemonLine);
   console.log(serverLine);
+  if (!health.ok) {
+    const startHint = stackName === 'main' ? 'happys dev' : `happys stack dev ${stackName}`;
+    console.log(`  ↪ this stack does not appear to be running. Start it with: ${startHint}`);
+    return;
+  }
   if (auth.ok && daemon.status !== 'running') {
-    console.log(`  ↪ auth is OK; this looks like a daemon/runtime issue. Try: happys doctor`);
+    console.log(`  ↪ daemon is not running for this stack. If you expected it to be running, try: happys doctor`);
   }
 }
 
@@ -240,7 +606,7 @@ async function main() {
   if (wantsHelp(argv, { flags }) || cmd === 'help') {
     printResult({
       json,
-      data: { commands: ['status', 'login'], stackScoped: 'happys stack auth <name> status|login' },
+      data: { commands: ['status', 'login', 'copy-from'], stackScoped: 'happys stack auth <name> status|login|copy-from' },
       text: [
         '[auth] usage:',
         '  happys auth status [--json]',
@@ -249,6 +615,7 @@ async function main() {
         'stack-scoped:',
         '  happys stack auth <name> status [--json]',
         '  happys stack auth <name> login [--force] [--print] [--json]',
+        '  happys stack auth <name> copy-from <sourceStack> [--json]',
       ].join('\n'),
     });
     return;
@@ -262,6 +629,10 @@ async function main() {
     await cmdLogin({ argv, json });
     return;
   }
+  if (cmd === 'copy-from') {
+    await cmdCopyFrom({ argv, json });
+    return;
+  }
 
   throw new Error(`[auth] unknown command: ${cmd}`);
 }