@starlight-ai/discord-waifus 0.1.0

package/dist/index.js

@@ -0,0 +1,1669 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import path8 from "path";
+import process4 from "process";
+import { spawnSync } from "child_process";
+import { promises as fs7 } from "fs";
+import { cac } from "cac";
+import { parse as parseToml } from "smol-toml";
+import pc2 from "picocolors";
+
+// src/config-store.ts
+import { promises as fs } from "fs";
+import os from "os";
+import path from "path";
+import { z } from "zod";
+var cliConfigSchema = z.object({
+  defaultProjectRoot: z.string().min(1).nullable().default(null)
+});
+function getCliConfigPath() {
+  const configHome = process.env.WAIFUS_CONFIG_HOME?.trim();
+  if (configHome) {
+    return path.resolve(configHome, "config.json");
+  }
+  return path.join(os.homedir(), ".config", "waifus", "config.json");
+}
+async function loadCliConfig() {
+  const filePath = getCliConfigPath();
+  try {
+    const raw = await fs.readFile(filePath, "utf8");
+    return cliConfigSchema.parse(JSON.parse(raw));
+  } catch (error) {
+    const code = error?.code;
+    if (code === "ENOENT") {
+      return cliConfigSchema.parse({});
+    }
+    throw error;
+  }
+}
+async function saveCliConfig(nextConfig) {
+  const filePath = getCliConfigPath();
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, `${JSON.stringify(cliConfigSchema.parse(nextConfig), null, 2)}
+`, "utf8");
+}
+
+// src/project-root.ts
+import { promises as fs2 } from "fs";
+import path2 from "path";
+var projectMarkers = [
+  "package.json",
+  "pnpm-workspace.yaml",
+  path2.join("packages", "backend"),
+  path2.join("packages", "dashboard"),
+  "defaults"
+];
+async function isValidProjectRoot(projectRoot) {
+  const resolvedRoot = path2.resolve(projectRoot);
+  for (const marker of projectMarkers) {
+    try {
+      await fs2.access(path2.join(resolvedRoot, marker));
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+async function resolveProjectRoot(options = {}) {
+  const cwd = path2.resolve(options.cwd ?? process.cwd());
+  const explicitProjectRoot = options.explicitProjectRoot ? path2.resolve(options.explicitProjectRoot) : null;
+  if (explicitProjectRoot && await isValidProjectRoot(explicitProjectRoot)) {
+    return explicitProjectRoot;
+  }
+  const config = await loadCliConfig();
+  if (config.defaultProjectRoot && await isValidProjectRoot(config.defaultProjectRoot)) {
+    return path2.resolve(config.defaultProjectRoot);
+  }
+  for (const candidate of walkParentDirectories(cwd)) {
+    if (await isValidProjectRoot(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+async function assertProjectRoot(projectRoot) {
+  const resolvedRoot = path2.resolve(projectRoot);
+  if (!await isValidProjectRoot(resolvedRoot)) {
+    throw new Error(
+      `Invalid Discord Waifus project root: ${resolvedRoot}
+Expected: package.json, pnpm-workspace.yaml, packages/backend/, packages/dashboard/, and defaults/`
+    );
+  }
+  return resolvedRoot;
+}
+function* walkParentDirectories(start) {
+  let current = start;
+  while (true) {
+    yield current;
+    const parent = path2.dirname(current);
+    if (parent === current) {
+      return;
+    }
+    current = parent;
+  }
+}
+
+// src/command-utils.ts
+import { promises as fs4 } from "fs";
+import path4 from "path";
+import process2 from "process";
+import { spawn } from "child_process";
+import pc from "picocolors";
+
+// src/runtime-layout.ts
+import { promises as fs3 } from "fs";
+import path3 from "path";
+import { stringify } from "smol-toml";
+function getRuntimeLayoutPaths(projectRoot) {
+  const defaultsRoot = path3.join(projectRoot, "defaults");
+  const runtimeRoot = path3.join(projectRoot, ".waifus");
+  const runtimeStateRoot = path3.join(runtimeRoot, "state");
+  const legacyConfigRoot = path3.join(projectRoot, "config");
+  const legacyDataRoot = path3.join(projectRoot, "data");
+  return {
+    defaultsRoot,
+    runtimeRoot,
+    runtimeConfigFile: path3.join(runtimeRoot, "config.toml"),
+    runtimeProvidersFile: path3.join(runtimeRoot, "providers.toml"),
+    runtimeKeysFile: path3.join(runtimeRoot, "keys.toml"),
+    runtimeChannelsFile: path3.join(runtimeRoot, "channels.toml"),
+    runtimeOrchestratorFile: path3.join(runtimeRoot, "orchestrator.toml"),
+    runtimeStageManagerFile: path3.join(runtimeRoot, "stage-manager.toml"),
+    runtimeWaifusRoot: path3.join(runtimeRoot, "waifus"),
+    runtimeStageManagerDataRoot: path3.join(runtimeRoot, "stage-manager-data"),
+    runtimeAssetsWaifusRoot: path3.join(runtimeRoot, "assets", "waifus"),
+    runtimeStateRoot,
+    migrationStateFile: path3.join(runtimeStateRoot, "migration-state.json"),
+    migrationWarningsFile: path3.join(runtimeStateRoot, "migration-warnings.json"),
+    stageManagerCheckpointsFile: path3.join(runtimeStateRoot, "stage-manager-checkpoints.json"),
+    defaultsConfigFile: path3.join(defaultsRoot, "config.toml"),
+    defaultsChannelsFile: path3.join(defaultsRoot, "channels.toml"),
+    defaultsOrchestratorFile: path3.join(defaultsRoot, "orchestrator.toml"),
+    defaultsStageManagerFile: path3.join(defaultsRoot, "stage-manager.toml"),
+    defaultsProviderCatalogFile: path3.join(defaultsRoot, "providers.catalog.json"),
+    defaultsWaifuTemplateFile: path3.join(defaultsRoot, "waifus", "default-waifu.json"),
+    legacyConfigRoot,
+    legacyDataRoot,
+    legacyWaifusFile: path3.join(legacyConfigRoot, "waifus.json"),
+    legacyProvidersFile: path3.join(legacyConfigRoot, "providers.json"),
+    legacyChannelsFile: path3.join(legacyConfigRoot, "channels.json"),
+    legacyOrchestratorFile: path3.join(legacyConfigRoot, "orchestrator.json"),
+    legacyStageManagerFile: path3.join(legacyConfigRoot, "stage-manager.json"),
+    legacyStageManagerStateFile: path3.join(legacyDataRoot, "stage-manager-state.json")
+  };
+}
+async function inspectRuntimeState(projectRoot) {
+  const paths = getRuntimeLayoutPaths(projectRoot);
+  const runtimeRootExists = await fileExists(paths.runtimeRoot);
+  const legacyLiveExists = await hasLegacyLiveConfig(projectRoot);
+  const migrationState = await readMigrationState(paths.migrationStateFile);
+  const isCanonicalLocalRuntime = Boolean(runtimeRootExists) && (migrationState?.status === "import_completed" || migrationState?.status === "bootstrap_empty" && !legacyLiveExists || !migrationState && !legacyLiveExists);
+  return {
+    paths,
+    runtimeRootExists,
+    legacyLiveExists,
+    migrationState,
+    isCanonicalLocalRuntime,
+    isMigrationPending: Boolean(runtimeRootExists && legacyLiveExists && migrationState?.status !== "import_completed")
+  };
+}
+async function hasLegacyLiveConfig(projectRoot) {
+  const paths = getRuntimeLayoutPaths(projectRoot);
+  const candidates = [
+    paths.legacyWaifusFile,
+    paths.legacyProvidersFile,
+    paths.legacyChannelsFile,
+    paths.legacyOrchestratorFile,
+    paths.legacyStageManagerFile,
+    paths.legacyStageManagerStateFile
+  ];
+  for (const candidate of candidates) {
+    if (await fileExists(candidate)) {
+      return true;
+    }
+  }
+  return false;
+}
+async function bootstrapLocalRuntime(projectRoot) {
+  const inspection = await inspectRuntimeState(projectRoot);
+  if (inspection.legacyLiveExists && inspection.migrationState?.status !== "import_completed") {
+    throw new Error("Legacy live config still exists. Run: waifus migrate-local-config");
+  }
+  return seedLocalRuntimeFromDefaults(projectRoot, {
+    writeBootstrapMigrationState: !inspection.migrationState && !inspection.legacyLiveExists
+  });
+}
+async function seedLocalRuntimeFromDefaults(projectRoot, options) {
+  const inspection = await inspectRuntimeState(projectRoot);
+  const paths = inspection.paths;
+  const written = [];
+  await Promise.all([
+    fs3.mkdir(paths.runtimeWaifusRoot, { recursive: true }),
+    fs3.mkdir(paths.runtimeStageManagerDataRoot, { recursive: true }),
+    fs3.mkdir(paths.runtimeAssetsWaifusRoot, { recursive: true }),
+    fs3.mkdir(paths.runtimeStateRoot, { recursive: true })
+  ]);
+  written.push(
+    await ensureCopied(paths.defaultsConfigFile, paths.runtimeConfigFile),
+    await ensureCopied(paths.defaultsChannelsFile, paths.runtimeChannelsFile),
+    await ensureSeededProviders(paths.defaultsProviderCatalogFile, paths.runtimeProvidersFile),
+    await ensureFile(paths.runtimeKeysFile, `${stringify({ provider_keys: [] })}
+`),
+    await ensureCopied(paths.defaultsOrchestratorFile, paths.runtimeOrchestratorFile),
+    await ensureCopied(paths.defaultsStageManagerFile, paths.runtimeStageManagerFile),
+    await ensureJsonFile(paths.stageManagerCheckpointsFile, { guilds: {} }),
+    await ensureJsonFile(paths.migrationWarningsFile, {
+      schemaVersion: 1,
+      globalWarnings: [],
+      waifuWarnings: {}
+    })
+  );
+  if (options.writeBootstrapMigrationState) {
+    written.push(
+      await ensureJsonFile(paths.migrationStateFile, {
+        schemaVersion: 1,
+        status: "bootstrap_empty",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        completedAt: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+  }
+  return written.filter(Boolean);
+}
+function defaultSeedFiles(projectRoot) {
+  const paths = getRuntimeLayoutPaths(projectRoot);
+  return [
+    paths.defaultsConfigFile,
+    paths.defaultsChannelsFile,
+    paths.defaultsOrchestratorFile,
+    paths.defaultsStageManagerFile,
+    paths.defaultsProviderCatalogFile,
+    paths.defaultsWaifuTemplateFile
+  ];
+}
+function localRuntimeFiles(projectRoot) {
+  const paths = getRuntimeLayoutPaths(projectRoot);
+  return [
+    paths.runtimeConfigFile,
+    paths.runtimeProvidersFile,
+    paths.runtimeKeysFile,
+    paths.runtimeChannelsFile,
+    paths.runtimeOrchestratorFile,
+    paths.runtimeStageManagerFile,
+    paths.migrationStateFile,
+    paths.migrationWarningsFile,
+    paths.stageManagerCheckpointsFile
+  ];
+}
+async function ensureSeededProviders(catalogFile, providersFile) {
+  if (await fileExists(providersFile)) {
+    return "";
+  }
+  const catalog = JSON.parse(await fs3.readFile(catalogFile, "utf8"));
+  const tomlValue = {
+    providers: (catalog.providers ?? []).map((entry) => ({
+      id: entry.id,
+      origin: "built-in",
+      name: entry.name,
+      type: entry.type,
+      auth_mode: entry.authMode ?? "required",
+      enabled: entry.enabledByDefault ?? false,
+      base_url: entry.baseUrl,
+      models: entry.models ?? []
+    }))
+  };
+  await fs3.mkdir(path3.dirname(providersFile), { recursive: true });
+  await fs3.writeFile(providersFile, `${stringify(tomlValue)}
+`, "utf8");
+  return providersFile;
+}
+async function ensureCopied(sourceFile, targetFile) {
+  if (await fileExists(targetFile)) {
+    return "";
+  }
+  const contents = await fs3.readFile(sourceFile, "utf8");
+  await fs3.mkdir(path3.dirname(targetFile), { recursive: true });
+  await fs3.writeFile(targetFile, contents, "utf8");
+  return targetFile;
+}
+async function ensureFile(targetFile, contents) {
+  if (await fileExists(targetFile)) {
+    return "";
+  }
+  await fs3.mkdir(path3.dirname(targetFile), { recursive: true });
+  await fs3.writeFile(targetFile, contents, "utf8");
+  return targetFile;
+}
+async function ensureJsonFile(targetFile, value) {
+  return ensureFile(targetFile, `${JSON.stringify(value, null, 2)}
+`);
+}
+async function readMigrationState(filePath) {
+  try {
+    return JSON.parse(await fs3.readFile(filePath, "utf8"));
+  } catch (error) {
+    const code = error?.code;
+    if (code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+async function fileExists(filePath) {
+  try {
+    await fs3.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/command-utils.ts
+async function requireProjectRoot(options) {
+  const projectRoot = await resolveProjectRoot({
+    cwd: process2.cwd(),
+    explicitProjectRoot: options.project ?? null
+  });
+  if (!projectRoot) {
+    throw new Error("No project root is configured.\nRun: waifus use /path/to/Discord-Waifus");
+  }
+  return projectRoot;
+}
+function runtimeConfigFiles(projectRoot) {
+  return [...defaultSeedFiles(projectRoot), ...localRuntimeFiles(projectRoot)];
+}
+function requiredBuildArtifacts(projectRoot) {
+  return [
+    path4.join(projectRoot, "packages", "backend", "dist", "index.js"),
+    path4.join(projectRoot, "packages", "dashboard", ".next", "BUILD_ID")
+  ];
+}
+async function fileExists2(filePath) {
+  try {
+    await fs4.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readJsonFile(filePath) {
+  return JSON.parse(await fs4.readFile(filePath, "utf8"));
+}
+async function spawnPassthrough(command, args, cwd, envOverrides = {}) {
+  await new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      stdio: "inherit",
+      env: {
+        ...process2.env,
+        ...envOverrides
+      }
+    });
+    child.once("error", reject);
+    child.once("exit", (code, signal) => {
+      if (signal) {
+        reject(new Error(`${command} exited due to signal ${signal}`));
+        return;
+      }
+      if (code && code !== 0) {
+        reject(new Error(`${command} ${args.join(" ")} failed with exit code ${code}`));
+        return;
+      }
+      resolve();
+    });
+  });
+}
+function info(message) {
+  console.log(pc.cyan(message));
+}
+function success(message) {
+  console.log(pc.green(message));
+}
+function warn(message) {
+  console.log(pc.yellow(message));
+}
+
+// src/open-url.ts
+import process3 from "process";
+import { spawn as spawn2 } from "child_process";
+async function openUrl(url) {
+  const platform = process3.platform;
+  if (platform === "darwin") {
+    await spawnDetached("open", [url]);
+    return;
+  }
+  if (platform === "win32") {
+    await spawnDetached("cmd", ["/c", "start", "", url]);
+    return;
+  }
+  await spawnDetached("xdg-open", [url]);
+}
+async function spawnDetached(command, args) {
+  await new Promise((resolve, reject) => {
+    const child = spawn2(command, args, {
+      detached: true,
+      stdio: "ignore",
+      env: process3.env
+    });
+    child.once("error", reject);
+    child.once("spawn", () => {
+      child.unref();
+      resolve();
+    });
+  });
+}
+
+// src/local-config-migrator.ts
+import { promises as fs5 } from "fs";
+import path5 from "path";
+import { stringify as stringify2 } from "smol-toml";
+async function migrateLocalConfig(projectRoot) {
+  const runtimeState = await inspectRuntimeState(projectRoot);
+  if (!runtimeState.legacyLiveExists) {
+    throw new Error("No legacy runtime files found to import.");
+  }
+  if (runtimeState.migrationState?.status === "import_completed") {
+    throw new Error("Legacy import already completed for this project.");
+  }
+  const paths = runtimeState.paths;
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const warnings = {
+    schemaVersion: 1,
+    globalWarnings: [],
+    waifuWarnings: {}
+  };
+  const [legacyWaifusFile, legacyProvidersFile, legacyChannelsFile, legacyOrchestratorFile, legacyStageManagerFile, legacyStageManagerStateFile, catalogFile] = await Promise.all([
+    readJson(paths.legacyWaifusFile, { waifus: [] }),
+    readJson(paths.legacyProvidersFile, { providers: [] }),
+    readJson(paths.legacyChannelsFile, { channels: [] }),
+    readJson(paths.legacyOrchestratorFile, {
+      orchestrator: {
+        providerId: "configure-me",
+        model: "configure-me",
+        temperature: 0.7,
+        maxTokens: 500
+      }
+    }),
+    readJson(paths.legacyStageManagerFile, {
+      stageManager: {
+        enabled: true,
+        providerId: null,
+        model: null,
+        temperature: 0.4,
+        maxTokens: 500,
+        quietPeriodSeconds: 300,
+        historyLimit: 60,
+        maxRelationshipsPerWaifu: 20,
+        maxMemoriesPerWaifu: 8
+      }
+    }),
+    readJson(paths.legacyStageManagerStateFile, {
+      waifus: {},
+      channels: {}
+    }),
+    readJson(paths.defaultsProviderCatalogFile, { providers: [] })
+  ]);
+  const idMap = buildWaifuIdMap(legacyWaifusFile.waifus);
+  const catalogById = new Map(catalogFile.providers.map((entry) => [entry.id, entry]));
+  const written = await seedLocalRuntimeFromDefaults(projectRoot, {
+    writeBootstrapMigrationState: false
+  });
+  const migratedWaifus = await Promise.all(
+    legacyWaifusFile.waifus.map(async (waifu) => {
+      const nextId = idMap[waifu.id];
+      const migratedAssets = await migrateWaifuAssets(
+        paths,
+        waifu,
+        nextId,
+        warnings,
+        timestamp
+      );
+      if (waifu.id !== nextId) {
+        addWaifuWarning(warnings, nextId, {
+          code: "legacy_id_sanitized",
+          field: "id",
+          message: `Legacy waifu id "${waifu.id}" was sanitized to "${nextId}".`,
+          legacyValue: waifu.id,
+          createdAt: timestamp
+        });
+      }
+      return {
+        schemaVersion: 1,
+        id: nextId,
+        name: waifu.name,
+        displayName: waifu.displayName,
+        botToken: waifu.botToken,
+        applicationId: waifu.applicationId,
+        enabled: waifu.enabled,
+        avatarPath: migratedAssets.avatarPath,
+        bannerPath: migratedAssets.bannerPath,
+        statusText: waifu.statusText,
+        statusType: waifu.statusType,
+        personality: {
+          ...waifu.personality,
+          relationshipsWithOtherWaifus: Object.fromEntries(
+            Object.entries(waifu.personality.relationshipsWithOtherWaifus).map(([relationshipId, value]) => [
+              idMap[relationshipId] ?? relationshipId,
+              value
+            ])
+          )
+        },
+        schedule: waifu.schedule,
+        ai: {
+          ...waifu.ai,
+          providerId: waifu.ai.providerId
+        }
+      };
+    })
+  );
+  const migratedChannels = legacyChannelsFile.channels.map((channel) => ({
+    guildId: channel.guildId,
+    channelId: channel.channelId,
+    channelName: channel.channelName,
+    enabled: channel.enabled,
+    activeWaifuIds: channel.activeWaifuIds.map((waifuId) => idMap[waifuId] ?? waifuId),
+    contextAnchorMessageId: channel.contextAnchorMessageId ?? "",
+    contextMessageCount: channel.contextMessageCount,
+    idleChatterEnabled: channel.idleChatterEnabled,
+    idleTimerMinSeconds: channel.idleTimerMinSeconds,
+    idleTimerMaxSeconds: channel.idleTimerMaxSeconds
+  }));
+  const migratedProviders = legacyProvidersFile.providers.map((provider) => {
+    const catalog = catalogById.get(provider.id);
+    return {
+      id: provider.id,
+      origin: catalog ? "built-in" : "custom",
+      name: provider.name,
+      type: provider.type,
+      authMode: catalog?.authMode ?? deriveAuthMode(provider.id),
+      enabled: provider.enabled,
+      baseUrl: provider.baseUrl,
+      models: provider.models
+    };
+  });
+  const migratedProviderKeys = legacyProvidersFile.providers.map((provider) => {
+    const authMode = catalogById.get(provider.id)?.authMode ?? deriveAuthMode(provider.id);
+    if (authMode === "none" || !provider.apiKey) {
+      return null;
+    }
+    return {
+      id: provider.id,
+      apiKey: provider.apiKey
+    };
+  }).filter((entry) => Boolean(entry));
+  const waifuGuilds = buildWaifuGuilds(migratedChannels);
+  const migratedStageManagerDocuments = Object.fromEntries(
+    migratedWaifus.map((waifu) => {
+      const legacyState = legacyStageManagerStateFile.waifus[findLegacyIdForNewId(idMap, waifu.id) ?? waifu.id];
+      const guildIds = [...waifuGuilds.get(waifu.id) ?? /* @__PURE__ */ new Set()];
+      const guilds = {};
+      if (legacyState) {
+        if (guildIds.length === 0) {
+          addWaifuWarning(warnings, waifu.id, {
+            code: "stage_manager_guild_missing",
+            field: "stageManager.guilds",
+            message: "Legacy stage-manager data could not be assigned because this waifu is not active in any migrated guild.",
+            createdAt: timestamp
+          });
+        }
+        if (guildIds.length > 1) {
+          addWaifuWarning(warnings, waifu.id, {
+            code: "stage_manager_state_duplicated",
+            field: "stageManager.guilds",
+            message: `Legacy stage-manager state was duplicated into ${guildIds.length} guild sections during import.`,
+            createdAt: timestamp
+          });
+        }
+      }
+      for (const guildId of guildIds) {
+        guilds[guildId] = {
+          relationshipsByParticipant: Object.fromEntries(
+            Object.entries(legacyState?.relationshipsByParticipant ?? {}).map(([participantKey, relationship]) => {
+              const targetWaifuId = relationship.targetWaifuId ? idMap[relationship.targetWaifuId] ?? relationship.targetWaifuId : null;
+              return [
+                remapParticipantKey(participantKey, idMap),
+                {
+                  ...relationship,
+                  targetWaifuId,
+                  targetName: relationship.targetKind === "waifu" && targetWaifuId ? migratedWaifus.find((candidate) => candidate.id === targetWaifuId)?.name ?? relationship.targetName : relationship.targetName
+                }
+              ];
+            })
+          ),
+          memories: [...legacyState?.memories ?? []]
+        };
+      }
+      return [
+        waifu.id,
+        {
+          schemaVersion: 1,
+          waifuId: waifu.id,
+          guilds
+        }
+      ];
+    })
+  );
+  const migratedCheckpoints = collapseLegacyCheckpoints(
+    legacyStageManagerStateFile.channels,
+    migratedChannels,
+    warnings,
+    timestamp
+  );
+  await Promise.all([
+    atomicWriteFile(
+      paths.runtimeProvidersFile,
+      `${stringify2({
+        providers: migratedProviders.map((provider) => ({
+          id: provider.id,
+          origin: provider.origin,
+          name: provider.name,
+          type: provider.type,
+          auth_mode: provider.authMode,
+          enabled: provider.enabled,
+          base_url: provider.baseUrl,
+          models: provider.models
+        }))
+      })}
+`
+    ),
+    atomicWriteFile(
+      paths.runtimeKeysFile,
+      `${stringify2({
+        provider_keys: migratedProviderKeys.map((entry) => ({
+          id: entry.id,
+          api_key: entry.apiKey
+        }))
+      })}
+`
+    ),
+    atomicWriteFile(
+      paths.runtimeChannelsFile,
+      `${stringify2({
+        channels: migratedChannels.map((channel) => ({
+          guild_id: channel.guildId,
+          channel_id: channel.channelId,
+          channel_name: channel.channelName,
+          enabled: channel.enabled,
+          active_waifu_ids: channel.activeWaifuIds,
+          context_anchor_message_id: channel.contextAnchorMessageId,
+          context_message_count: channel.contextMessageCount,
+          idle_chatter_enabled: channel.idleChatterEnabled,
+          idle_timer_min_seconds: channel.idleTimerMinSeconds,
+          idle_timer_max_seconds: channel.idleTimerMaxSeconds
+        }))
+      })}
+`
+    ),
+    atomicWriteFile(
+      paths.runtimeOrchestratorFile,
+      `${stringify2({
+        orchestrator: {
+          provider_id: asRecord(legacyOrchestratorFile).orchestrator?.providerId ?? "configure-me",
+          model: asRecord(legacyOrchestratorFile).orchestrator?.model ?? "configure-me",
+          temperature: asRecord(legacyOrchestratorFile).orchestrator?.temperature ?? 0.7,
+          max_tokens: asRecord(legacyOrchestratorFile).orchestrator?.maxTokens ?? 500
+        }
+      })}
+`
+    ),
+    atomicWriteFile(
+      paths.runtimeStageManagerFile,
+      `${stringify2({
+        stage_manager: {
+          enabled: asRecord(legacyStageManagerFile).stageManager?.enabled ?? true,
+          provider_id: asRecord(legacyStageManagerFile).stageManager?.providerId ?? "",
+          model: asRecord(legacyStageManagerFile).stageManager?.model ?? "",
+          temperature: asRecord(legacyStageManagerFile).stageManager?.temperature ?? 0.4,
+          max_tokens: asRecord(legacyStageManagerFile).stageManager?.maxTokens ?? 500,
+          quiet_period_seconds: asRecord(legacyStageManagerFile).stageManager?.quietPeriodSeconds ?? 300,
+          history_limit: asRecord(legacyStageManagerFile).stageManager?.historyLimit ?? 60,
+          max_relationships_per_waifu: asRecord(legacyStageManagerFile).stageManager?.maxRelationshipsPerWaifu ?? 20,
+          max_memories_per_waifu: asRecord(legacyStageManagerFile).stageManager?.maxMemoriesPerWaifu ?? 8
+        }
+      })}
+`
+    ),
+    atomicWriteFile(
+      paths.stageManagerCheckpointsFile,
+      `${JSON.stringify({ guilds: migratedCheckpoints }, null, 2)}
+`
+    ),
+    atomicWriteFile(
+      paths.migrationWarningsFile,
+      `${JSON.stringify(warnings, null, 2)}
+`
+    ),
+    atomicWriteFile(
+      paths.migrationStateFile,
+      `${JSON.stringify(
+        {
+          schemaVersion: 1,
+          status: "import_completed",
+          createdAt: timestamp,
+          completedAt: timestamp
+        },
+        null,
+        2
+      )}
+`
+    )
+  ]);
+  written.push(
+    paths.runtimeProvidersFile,
+    paths.runtimeKeysFile,
+    paths.runtimeChannelsFile,
+    paths.runtimeOrchestratorFile,
+    paths.runtimeStageManagerFile,
+    paths.stageManagerCheckpointsFile,
+    paths.migrationWarningsFile,
+    paths.migrationStateFile
+  );
+  for (const waifu of migratedWaifus) {
+    const waifuPath = path5.join(paths.runtimeWaifusRoot, `${waifu.id}.json`);
+    const stageManagerPath = path5.join(paths.runtimeStageManagerDataRoot, `${waifu.id}.json`);
+    await atomicWriteFile(waifuPath, `${JSON.stringify(waifu, null, 2)}
+`);
+    await atomicWriteFile(
+      stageManagerPath,
+      `${JSON.stringify(migratedStageManagerDocuments[waifu.id], null, 2)}
+`
+    );
+    written.push(waifuPath, stageManagerPath);
+  }
+  return {
+    written: [...new Set(written)],
+    idMap,
+    warningCount: warnings.globalWarnings.length + Object.values(warnings.waifuWarnings).reduce((count, entries) => count + entries.length, 0)
+  };
+}
+function buildWaifuIdMap(waifus) {
+  const used = /* @__PURE__ */ new Set();
+  const idMap = {};
+  for (const waifu of waifus) {
+    const baseId = sanitizeWaifuId(waifu.id);
+    let nextId = baseId;
+    let suffix = 2;
+    while (used.has(nextId)) {
+      nextId = `${baseId}_${suffix}`;
+      suffix += 1;
+    }
+    used.add(nextId);
+    idMap[waifu.id] = nextId;
+  }
+  return idMap;
+}
+function sanitizeWaifuId(value) {
+  const sanitized = value.replace(/[^A-Za-z0-9_-]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
+  return sanitized || "Waifu_1";
+}
+function buildWaifuGuilds(channels) {
+  const result = /* @__PURE__ */ new Map();
+  for (const channel of channels) {
+    for (const waifuId of channel.activeWaifuIds) {
+      const guilds = result.get(waifuId) ?? /* @__PURE__ */ new Set();
+      guilds.add(channel.guildId);
+      result.set(waifuId, guilds);
+    }
+  }
+  return result;
+}
+function collapseLegacyCheckpoints(checkpoints, channels, warnings, timestamp) {
+  const guildByChannelId = new Map(channels.map((channel) => [channel.channelId, channel.guildId]));
+  const grouped = /* @__PURE__ */ new Map();
+  for (const [channelId, checkpoint] of Object.entries(checkpoints)) {
+    const guildId = guildByChannelId.get(channelId);
+    if (!guildId) {
+      warnings.globalWarnings.push({
+        code: "legacy_checkpoint_orphaned",
+        field: "stageManager.checkpoints",
+        message: `Legacy checkpoint for channel "${channelId}" could not be mapped to a migrated guild.`,
+        legacyValue: channelId,
+        createdAt: timestamp
+      });
+      continue;
+    }
+    const entries = grouped.get(guildId) ?? [];
+    entries.push({ channelId, ...checkpoint });
+    grouped.set(guildId, entries);
+  }
+  return Object.fromEntries(
+    [...grouped.entries()].map(([guildId, entries]) => {
+      const withMessageId = entries.filter((entry) => entry.lastProcessedMessageId);
+      const highestMessage = withMessageId.sort(
+        (left, right) => compareMessageIds(left.lastProcessedMessageId, right.lastProcessedMessageId)
+      )[withMessageId.length - 1];
+      const latestRun = entries.filter((entry) => entry.lastRunAt).sort((left, right) => String(left.lastRunAt).localeCompare(String(right.lastRunAt))).at(-1);
+      if (entries.length > 1) {
+        warnings.globalWarnings.push({
+          code: "legacy_checkpoints_collapsed",
+          field: `stageManager.checkpoints.${guildId}`,
+          message: `Collapsed ${entries.length} channel checkpoints into one guild checkpoint for "${guildId}".`,
+          createdAt: timestamp
+        });
+      }
+      return [
+        guildId,
+        {
+          lastProcessedMessageId: highestMessage?.lastProcessedMessageId ?? null,
+          lastRunAt: latestRun?.lastRunAt ?? null
+        }
+      ];
+    })
+  );
+}
+function compareMessageIds(left, right) {
+  if (!left && !right) {
+    return 0;
+  }
+  if (!left) {
+    return -1;
+  }
+  if (!right) {
+    return 1;
+  }
+  try {
+    const leftValue = BigInt(left);
+    const rightValue = BigInt(right);
+    return leftValue < rightValue ? -1 : leftValue > rightValue ? 1 : 0;
+  } catch {
+    return left.localeCompare(right);
+  }
+}
+async function migrateWaifuAssets(paths, waifu, waifuId, warnings, timestamp) {
+  return {
+    avatarPath: await migrateAssetField(paths, waifu, waifuId, "avatarPath", "avatar", warnings, timestamp),
+    bannerPath: await migrateAssetField(paths, waifu, waifuId, "bannerPath", "banner", warnings, timestamp)
+  };
+}
+async function migrateAssetField(paths, waifu, waifuId, key, stem, warnings, timestamp) {
+  const value = waifu[key];
+  if (!value || !value.trim()) {
+    return null;
+  }
+  const sourcePath = await resolveLegacyAssetPath(paths, value);
+  if (!sourcePath) {
+    addWaifuWarning(warnings, waifuId, {
+      code: "legacy_asset_unresolved",
+      field: key,
+      message: `Legacy ${stem} asset could not be resolved during import.`,
+      legacyValue: value,
+      createdAt: timestamp
+    });
+    return null;
+  }
+  const extension = path5.extname(sourcePath) || ".png";
+  const destinationDir = path5.join(paths.runtimeAssetsWaifusRoot, waifuId);
+  const destinationPath = path5.join(destinationDir, `${stem}${extension}`);
+  await fs5.mkdir(destinationDir, { recursive: true });
+  await fs5.copyFile(sourcePath, destinationPath);
+  return path5.posix.join("waifus", waifuId, `${stem}${extension}`);
+}
+async function resolveLegacyAssetPath(paths, value) {
+  const trimmed = value.trim();
+  const candidates = [
+    trimmed,
+    path5.join(path5.dirname(paths.legacyConfigRoot), trimmed.replace(/^\.\//, "")),
+    path5.join(paths.legacyConfigRoot, trimmed.replace(/^\.\/?config\/assets\//, "").replace(/^config\/assets\//, "").replace(/^\.\/assets\//, "").replace(/^assets\//, ""))
+  ];
+  for (const candidate of candidates) {
+    const resolved = path5.isAbsolute(candidate) ? candidate : path5.resolve(candidate);
+    if (await fileExists3(resolved)) {
+      return resolved;
+    }
+  }
+  return null;
+}
+function remapParticipantKey(value, idMap) {
+  const match = value.match(/^waifu:(.+)$/);
+  if (!match) {
+    return value;
+  }
+  return `waifu:${idMap[match[1]] ?? match[1]}`;
+}
+function findLegacyIdForNewId(idMap, nextId) {
+  return Object.entries(idMap).find(([, mapped]) => mapped === nextId)?.[0] ?? null;
+}
+function deriveAuthMode(providerId) {
+  return providerId === "ollama" || providerId === "lmstudio" ? "none" : "required";
+}
+function addWaifuWarning(warnings, waifuId, warning) {
+  warnings.waifuWarnings[waifuId] = warnings.waifuWarnings[waifuId] ?? [];
+  warnings.waifuWarnings[waifuId].push(warning);
+}
+function asRecord(value) {
+  return value && typeof value === "object" ? value : {};
+}
+async function readJson(filePath, fallback) {
+  try {
+    return JSON.parse(await fs5.readFile(filePath, "utf8"));
+  } catch (error) {
+    const code = error?.code;
+    if (code === "ENOENT") {
+      return fallback;
+    }
+    throw error;
+  }
+}
+async function atomicWriteFile(filePath, contents) {
+  await fs5.mkdir(path5.dirname(filePath), { recursive: true });
+  const tempPath = `${filePath}.tmp`;
+  await fs5.writeFile(tempPath, contents, "utf8");
+  await fs5.rename(tempPath, filePath);
+}
+async function fileExists3(filePath) {
+  try {
+    await fs5.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/pm2-manager.ts
+import { createRequire } from "module";
+import path6 from "path";
+
+// src/service-env.ts
+function getServiceEnv(service) {
+  if (service === "backend") {
+    return {
+      NODE_ENV: "production"
+    };
+  }
+  return {
+    NODE_ENV: "production",
+    PORT: "3000"
+  };
+}
+
+// src/pm2-manager.ts
+var require2 = createRequire(import.meta.url);
+var backendProcessName = "waifus-backend";
+var dashboardProcessName = "waifus-dashboard";
+async function startServices(projectRoot) {
+  await withPm2(async () => {
+    await ensureStarted({
+      name: backendProcessName,
+      cwd: projectRoot,
+      script: "pnpm",
+      args: ["--filter", "backend", "start"],
+      env: getServiceEnv("backend")
+    });
+    await ensureStarted({
+      name: dashboardProcessName,
+      cwd: projectRoot,
+      script: "pnpm",
+      args: ["--filter", "dashboard", "start"],
+      env: getServiceEnv("dashboard")
+    });
+  });
+}
+async function stopServices() {
+  await withPm2(async () => {
+    await stopIfPresent(backendProcessName);
+    await stopIfPresent(dashboardProcessName);
+  });
+}
+async function restartServices(projectRoot) {
+  await withPm2(async () => {
+    await restartOrStart({
+      name: backendProcessName,
+      cwd: projectRoot,
+      script: "pnpm",
+      args: ["--filter", "backend", "start"],
+      env: getServiceEnv("backend")
+    });
+    await restartOrStart({
+      name: dashboardProcessName,
+      cwd: projectRoot,
+      script: "pnpm",
+      args: ["--filter", "dashboard", "start"],
+      env: getServiceEnv("dashboard")
+    });
+  });
+}
+async function listManagedServices() {
+  return withPm2(async () => {
+    const processes = await listProcesses();
+    return processes.filter(
+      (processDescription) => [backendProcessName, dashboardProcessName].includes(processDescription.name ?? "")
+    ).map((processDescription) => ({
+      name: processDescription.name ?? "unknown",
+      status: processDescription.pm2_env?.status ?? "unknown",
+      cwd: processDescription.pm2_env?.pm_cwd ?? null,
+      pid: typeof processDescription.pid === "number" ? processDescription.pid : null,
+      restartCount: processDescription.pm2_env?.restart_time ?? 0,
+      uptimeMs: typeof processDescription.pm2_env?.pm_uptime === "number" ? Date.now() - processDescription.pm2_env.pm_uptime : null
+    }));
+  });
+}
+function getPm2LogCommand(service, lines) {
+  const pm2Bin = resolvePm2Bin();
+  const args = ["logs"];
+  if (service === "backend") {
+    args.push(backendProcessName);
+  } else if (service === "dashboard") {
+    args.push(dashboardProcessName);
+  } else {
+    args.push(backendProcessName, dashboardProcessName);
+  }
+  args.push("--lines", String(lines));
+  return {
+    command: process.execPath,
+    args: [pm2Bin, ...args]
+  };
+}
+async function ensureStarted(options) {
+  if (await hasManagedProcess(options.name ?? "")) {
+    await restartProcess(options.name ?? "");
+    return;
+  }
+  await startProcess(options);
+}
+async function restartOrStart(options) {
+  if (await hasManagedProcess(options.name ?? "")) {
+    await restartProcess(options.name ?? "");
+    return;
+  }
+  await startProcess(options);
+}
+async function stopIfPresent(processName) {
+  if (!await hasManagedProcess(processName)) {
+    return;
+  }
+  await stopProcess(processName);
+}
+async function withPm2(callback) {
+  const pm2 = await loadPm2();
+  await connect(pm2);
+  try {
+    return await callback();
+  } finally {
+    pm2.disconnect();
+  }
+}
+function connect(pm2) {
+  return new Promise((resolve, reject) => {
+    pm2.connect((error) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });
+}
+async function startProcess(options) {
+  const pm2 = await loadPm2();
+  return new Promise((resolve, reject) => {
+    pm2.start(options, (error) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });
+}
+async function restartProcess(processName) {
+  const pm2 = await loadPm2();
+  return new Promise((resolve, reject) => {
+    pm2.restart(processName, (error) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });
+}
+async function stopProcess(processName) {
+  const pm2 = await loadPm2();
+  return new Promise((resolve, reject) => {
+    pm2.stop(processName, (error) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });
+}
+async function listProcesses() {
+  const pm2 = await loadPm2();
+  return new Promise((resolve, reject) => {
+    pm2.list((error, processDescription) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve(processDescription);
+    });
+  });
+}
+async function hasManagedProcess(processName) {
+  const processes = await listProcesses();
+  return processes.some((processDescription) => processDescription.name === processName);
+}
+var pm2Promise = null;
+async function loadPm2() {
+  if (!pm2Promise) {
+    pm2Promise = Promise.resolve(require2("pm2"));
+  }
+  return pm2Promise;
+}
+function resolvePm2Bin() {
+  return require2.resolve(path6.join("pm2", "bin", "pm2"));
+}
+
+// src/repo-bootstrap.ts
+import { promises as fs6 } from "fs";
+import os2 from "os";
+import path7 from "path";
+import { spawn as spawn3 } from "child_process";
+async function bootstrapRepoFromGitHubArchive(targetDir, options = {}) {
+  const projectRoot = path7.resolve(targetDir);
+  await ensureTargetDirectoryIsEmpty(projectRoot);
+  const repositoryUrl = options.repo?.trim() || await resolveRepositoryFromPackageMetadata();
+  if (!repositoryUrl) {
+    throw new Error(
+      "No GitHub repository was provided.\nUse: waifus init <target-dir> --repo https://github.com/<owner>/<repo>"
+    );
+  }
+  const githubRepo = parseGitHubRepository(repositoryUrl);
+  if (!githubRepo) {
+    throw new Error(
+      `Unsupported repository: ${repositoryUrl}
+Only GitHub repositories are supported by waifus init.`
+    );
+  }
+  const ref = options.ref?.trim() || null;
+  const archiveUrl = buildGitHubArchiveUrl(githubRepo.owner, githubRepo.repo, ref);
+  const tempRoot = await fs6.mkdtemp(path7.join(os2.tmpdir(), "waifus-init-"));
+  const archivePath = path7.join(tempRoot, "repo.tar.gz");
+  const extractRoot = path7.join(tempRoot, "extract");
+  try {
+    await fs6.mkdir(extractRoot, { recursive: true });
+    await downloadFile(archiveUrl, archivePath);
+    await extractTarGz(archivePath, extractRoot);
+    const extractedRoot = await findSingleExtractedRoot(extractRoot);
+    await fs6.mkdir(projectRoot, { recursive: true });
+    await copyDirectoryContents(extractedRoot, projectRoot);
+    return {
+      projectRoot,
+      sourceRepo: `https://github.com/${githubRepo.owner}/${githubRepo.repo}`,
+      sourceRef: ref
+    };
+  } finally {
+    await fs6.rm(tempRoot, { recursive: true, force: true });
+  }
+}
+async function ensureTargetDirectoryIsEmpty(targetDir) {
+  try {
+    const stats = await fs6.stat(targetDir);
+    if (!stats.isDirectory()) {
+      throw new Error(`Target path exists and is not a directory: ${targetDir}`);
+    }
+    const entries = await fs6.readdir(targetDir);
+    if (entries.length > 0) {
+      throw new Error(`Target directory is not empty: ${targetDir}`);
+    }
+  } catch (error) {
+    const code = error?.code;
+    if (code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
+}
+async function resolveRepositoryFromPackageMetadata() {
+  try {
+    const packageJsonPath = new URL("../package.json", import.meta.url);
+    const raw = JSON.parse(await fs6.readFile(packageJsonPath, "utf8"));
+    if (typeof raw.repository === "string" && raw.repository.trim()) {
+      return raw.repository.trim();
+    }
+    if (raw.repository && typeof raw.repository === "object" && typeof raw.repository.url === "string" && raw.repository.url.trim()) {
+      return raw.repository.url.trim();
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function parseGitHubRepository(value) {
+  const trimmed = value.trim();
+  const normalized = trimmed.replace(/^git\+/, "").replace(/^git@github\.com:/, "https://github.com/").replace(/\.git$/, "");
+  const slugMatch = normalized.match(/^([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)$/);
+  if (slugMatch) {
+    return { owner: slugMatch[1], repo: slugMatch[2] };
+  }
+  try {
+    const url = new URL(normalized);
+    if (url.hostname !== "github.com") {
+      return null;
+    }
+    const segments = url.pathname.replace(/^\/+|\/+$/g, "").split("/");
+    if (segments.length < 2 || !segments[0] || !segments[1]) {
+      return null;
+    }
+    return {
+      owner: segments[0],
+      repo: segments[1]
+    };
+  } catch {
+    return null;
+  }
+}
+function buildGitHubArchiveUrl(owner, repo, ref) {
+  const encodedRef = ref ? `/${encodeURIComponent(ref)}` : "";
+  return `https://api.github.com/repos/${owner}/${repo}/tarball${encodedRef}`;
+}
+async function downloadFile(url, destinationPath) {
+  const response = await fetch(url, {
+    headers: {
+      "User-Agent": "@starlight-ai/discord-waifus"
+    },
+    redirect: "follow"
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to download repository archive: HTTP ${response.status}`);
+  }
+  const buffer = Buffer.from(await response.arrayBuffer());
+  await fs6.writeFile(destinationPath, buffer);
+}
+async function extractTarGz(archivePath, extractRoot) {
+  await spawnQuiet("tar", ["-xzf", archivePath, "-C", extractRoot]);
+}
+async function findSingleExtractedRoot(extractRoot) {
+  const entries = await fs6.readdir(extractRoot, { withFileTypes: true });
+  const directories = entries.filter((entry) => entry.isDirectory());
+  if (directories.length !== 1) {
+    throw new Error("Repository archive extraction did not produce a single root directory.");
+  }
+  return path7.join(extractRoot, directories[0].name);
+}
+async function copyDirectoryContents(sourceDir, targetDir) {
+  const entries = await fs6.readdir(sourceDir);
+  await Promise.all(
+    entries.map(
+      (entry) => fs6.cp(path7.join(sourceDir, entry), path7.join(targetDir, entry), {
+        recursive: true
+      })
+    )
+  );
+}
+async function spawnQuiet(command, args) {
+  await new Promise((resolve, reject) => {
+    const child = spawn3(command, args, {
+      stdio: "ignore"
+    });
+    child.once("error", reject);
+    child.once("exit", (code, signal) => {
+      if (signal) {
+        reject(new Error(`${command} exited due to signal ${signal}`));
+        return;
+      }
+      if (code && code !== 0) {
+        reject(new Error(`${command} ${args.join(" ")} failed with exit code ${code}`));
+        return;
+      }
+      resolve();
+    });
+  });
+}
+
+// src/index.ts
+var cli = cac("waifus");
+cli.option("--project <path>", "Override the project root for this command");
+cli.command("use <projectPath>", "Store the default Discord Waifus project root for future commands").action(async (projectPath) => {
+  try {
+    const resolvedRoot = await assertProjectRoot(projectPath);
+    await saveCliConfig({ defaultProjectRoot: resolvedRoot });
+    console.log(pc2.green(`Default project root saved: ${resolvedRoot}`));
+  } catch (error) {
+    fail(error);
+  }
+});
+cli.command("init <targetDir>", "Download the Discord Waifus repo into a target directory and register it").option("--repo <repo>", "GitHub repo URL or owner/repo slug. If omitted, uses the package repository when available.").option("--ref <ref>", "Git ref, branch, or tag to download. Defaults to the repo default branch.").option("--no-install", "Skip pnpm install after download").action(async (targetDir, options) => {
+  try {
+    const result = await bootstrapRepoFromGitHubArchive(targetDir, {
+      repo: options.repo ?? null,
+      ref: options.ref ?? null
+    });
+    await assertProjectRoot(result.projectRoot);
+    success(`Downloaded project into ${result.projectRoot}`);
+    info(`Source: ${result.sourceRepo}${result.sourceRef ? ` @ ${result.sourceRef}` : ""}`);
+    await saveCliConfig({ defaultProjectRoot: result.projectRoot });
+    success(`Default project root saved: ${result.projectRoot}`);
+    if (options.install !== false) {
+      info("Installing project dependencies with pnpm...");
+      await spawnPassthrough("pnpm", ["install"], result.projectRoot);
+      success("Dependencies installed.");
+    } else {
+      warn("Skipped pnpm install. Run `pnpm install` inside the project before building.");
+    }
+    info("Next steps:");
+    info(`- waifus build`);
+    info(`- waifus init-config`);
+    info(`- waifus start`);
+  } catch (error) {
+    fail(error);
+  }
+});
+cli.command("doctor", "Validate the local setup").action(async () => {
+  try {
+    const projectRoot = await requireProjectRoot(cli.options);
+    const nodeMajor = Number.parseInt(process4.versions.node.split(".")[0] ?? "0", 10);
+    const pnpmVersion = spawnSync("pnpm", ["--version"], { encoding: "utf8" });
+    const configFiles = runtimeConfigFiles(projectRoot);
+    const artifactFiles = requiredBuildArtifacts(projectRoot);
+    const runtimeState = await inspectRuntimeState(projectRoot);
+    console.log(pc2.bold("waifus doctor"));
+    info(`Project root: ${projectRoot}`);
+    if (Number.isFinite(nodeMajor) && nodeMajor >= 20) {
+      success(`Node.js ${process4.versions.node}`);
+    } else {
+      warn(`Node.js ${process4.versions.node} detected. Recommended: Node.js 20+`);
+    }
+    if (pnpmVersion.status === 0) {
+      success(`pnpm ${pnpmVersion.stdout.trim()}`);
+    } else {
+      warn("pnpm not found in PATH");
+    }
+    if (runtimeState.isCanonicalLocalRuntime) {
+      success("Canonical local runtime detected: .waifus/");
+    } else if (runtimeState.isMigrationPending) {
+      warn("Migration pending: legacy config still takes precedence until import completes.");
+    } else if (runtimeState.legacyLiveExists) {
+      warn("Legacy runtime detected. Local .waifus/ bootstrap is blocked until migration.");
+    } else {
+      warn("Local runtime not initialized. Run: waifus init-config");
+    }
+    for (const configFile of configFiles) {
+      if (await fileExists2(configFile)) {
+        success(`Config present: ${path8.relative(projectRoot, configFile)}`);
+      } else {
+        warn(`Missing config: ${path8.relative(projectRoot, configFile)} (run: waifus init-config)`);
+      }
+    }
+    for (const artifactFile of artifactFiles) {
+      if (await fileExists2(artifactFile)) {
+        success(`Build artifact present: ${path8.relative(projectRoot, artifactFile)}`);
+      } else {
+        warn(`Build artifact missing: ${path8.relative(projectRoot, artifactFile)}`);
+      }
+    }
+    const filesToScan = runtimeState.isCanonicalLocalRuntime || runtimeState.runtimeRootExists && !runtimeState.legacyLiveExists ? [
+      ...localRuntimeFiles(projectRoot),
+      ...await listWaifuDocumentFiles(projectRoot)
+    ] : [
+      ...legacyConfigFiles(projectRoot)
+    ];
+    for (const configFile of filesToScan) {
+      if (!await fileExists2(configFile)) {
+        continue;
+      }
+      const configValue = await readConfigFile(configFile);
+      if (configValue === null) {
+        warn(`Could not parse config: ${path8.relative(projectRoot, configFile)}`);
+        continue;
+      }
+      for (const envReference of findEnvReferences(configValue)) {
+        if (process4.env[envReference.variableName]) {
+          success(
+            `Environment value resolved for ${envReference.variableName} in ${path8.relative(projectRoot, configFile)}`
+          );
+        } else {
+          warn(
+            `Unresolved ${envReference.raw} in ${path8.relative(projectRoot, configFile)}. Export ${envReference.variableName} before start.`
+          );
+        }
+      }
+      if (configFile.endsWith(path8.join(".waifus", "orchestrator.toml")) || configFile.endsWith(path8.join("config", "orchestrator.json"))) {
+        const orchestrator = "orchestrator" in configValue ? configValue.orchestrator ?? {} : {};
+        const providerValue = typeof orchestrator.providerId === "string" ? orchestrator.providerId : typeof orchestrator.provider_id === "string" ? orchestrator.provider_id : "";
+        const modelValue = typeof orchestrator.model === "string" ? orchestrator.model : "";
+        if (providerValue === "configure-me" || providerValue === "" || modelValue === "configure-me" || modelValue === "") {
+          warn("Orchestrator config is still unconfigured. Update it in the dashboard before relying on orchestration.");
+        }
+      }
+    }
+    if (runtimeState.runtimeRootExists && runtimeState.migrationState) {
+      info(`Migration state: ${runtimeState.migrationState.status}`);
+    }
+    info("If you edit config on disk, apply it with: waifus restart");
+  } catch (error) {
+    fail(error);
+  }
+});
+cli.command("build", "Build backend, dashboard, and CLI").action(async () => {
+  try {
+    const projectRoot = await requireProjectRoot(cli.options);
+    await spawnPassthrough("pnpm", ["build"], projectRoot);
+  } catch (error) {
+    fail(error);
+  }
+});
+cli.command("init-config", "Create or repair the local .waifus runtime layout from defaults/").option("--force", "Reserved for future explicit empty-bootstrap overrides").action(async () => {
+  try {
+    const projectRoot = await requireProjectRoot(cli.options);
+    const legacyLiveExists = await hasLegacyLiveConfig(projectRoot);
+    const runtimeState = await inspectRuntimeState(projectRoot);
+    if (legacyLiveExists && runtimeState.migrationState?.status !== "import_completed") {
+      throw new Error("Legacy live config still exists. Run: waifus migrate-local-config");
+    }
+    const written = await bootstrapLocalRuntime(projectRoot);
+    if (written.length === 0) {
+      info("Local runtime layout already satisfied.");
+    } else {
+      for (const filePath of written) {
+        success(`Wrote ${path8.relative(projectRoot, filePath)}`);
+      }
+    }
+    info("Finish configuration in the dashboard after start.");
+    info("If you later edit config on disk, apply it with: waifus restart");
+  } catch (error) {
+    fail(error);
+  }
+});
+cli.command("migrate-local-config", "Import legacy config/*.json runtime data into the local .waifus layout").action(async () => {
+  try {
+    const projectRoot = await requireProjectRoot(cli.options);
+    const result = await migrateLocalConfig(projectRoot);
+    success(`Imported legacy runtime into .waifus/ (${result.written.length} files written).`);
+    if (Object.keys(result.idMap).some((legacyId) => legacyId !== result.idMap[legacyId])) {
+      info("Sanitized waifu IDs:");
+      for (const [legacyId, nextId] of Object.entries(result.idMap)) {
+        if (legacyId === nextId) {
+          continue;
+        }
+        info(`- ${legacyId} -> ${nextId}`);
+      }
+    }
+    if (result.warningCount > 0) {
+      warn(
+        `Migration completed with ${result.warningCount} warning(s). Review ${path8.relative(projectRoot, getRuntimeLayoutPaths(projectRoot).migrationWarningsFile)}`
+      );
+    } else {
+      success("Migration warnings: none");
+    }
+    info("Legacy files were left untouched. After reviewing the import, apply it with: waifus restart");
+  } catch (error) {
+    fail(error);
+  }
+});
+cli.command("start", "Start backend and dashboard under PM2").action(async () => {
+  try {
+    const projectRoot = await requireProjectRoot(cli.options);
+    await assertNoPendingLegacyMigration(projectRoot);
+    for (const artifactFile of requiredBuildArtifacts(projectRoot)) {
+      if (!await fileExists2(artifactFile)) {
+        throw new Error(
+          `Missing build artifact: ${path8.relative(projectRoot, artifactFile)}
+Run: waifus build`
+        );
+      }
+    }
+    await startServices(projectRoot);
+    success("Started waifus-backend and waifus-dashboard through PM2.");
+    info("Local dashboard: http://localhost:3000");
+    info("Local backend: http://127.0.0.1:4000");
+    warn("These services are local to this machine.");
+    info("If you edit config on disk, apply it with: waifus restart");
+  } catch (error) {
+    fail(error);
+  }
+});
+cli.command("stop", "Stop PM2-managed backend and dashboard").action(async () => {
+  try {
+    await requireProjectRoot(cli.options);
+    await stopServices();
+    success("Stopped waifus-backend and waifus-dashboard.");
+  } catch (error) {
+    fail(error);
+  }
+});
+cli.command("restart", "Restart PM2-managed backend and dashboard").action(async () => {
+  try {
+    const projectRoot = await requireProjectRoot(cli.options);
+    await assertNoPendingLegacyMigration(projectRoot);
+    for (const artifactFile of requiredBuildArtifacts(projectRoot)) {
+      if (!await fileExists2(artifactFile)) {
+        throw new Error(
+          `Missing build artifact: ${path8.relative(projectRoot, artifactFile)}
+Run: waifus build`
+        );
+      }
+    }
+    await restartServices(projectRoot);
+    success("Restarted waifus-backend and waifus-dashboard.");
+    info("Local dashboard: http://localhost:3000");
+    info("Local backend: http://127.0.0.1:4000");
+    warn("These services are local to this machine.");
+    info("Config changes on disk are now applied.");
+  } catch (error) {
+    fail(error);
+  }
+});
+cli.command("status", "Show PM2 service status").action(async () => {
+  try {
+    await requireProjectRoot(cli.options);
+    const services = await listManagedServices();
+    console.log(pc2.bold("waifus status"));
+    if (services.length === 0) {
+      warn("No managed waifus PM2 services found.");
+    } else {
+      for (const service of services) {
+        console.log(
+          [
+            `- ${service.name}`,
+            `  status: ${service.status}`,
+            `  cwd: ${service.cwd ?? "unknown"}`,
+            `  pid: ${service.pid ?? "not running"}`,
+            `  restarts: ${service.restartCount}`,
+            `  uptimeMs: ${service.uptimeMs ?? "unknown"}`
+          ].join("\n")
+        );
+      }
+    }
+    try {
+      const response = await fetch("http://127.0.0.1:4000/api/status");
+      if (response.ok) {
+        const payload = await response.json();
+        info(`Backend health: reachable on 127.0.0.1:4000 (uptimeSeconds=${payload.uptimeSeconds ?? "unknown"})`);
+      } else {
+        warn(`Backend health check returned HTTP ${response.status}`);
+      }
+    } catch {
+      warn("Backend health: not reachable on 127.0.0.1:4000");
+    }
+    warn("These services are local to this machine.");
+  } catch (error) {
+    fail(error);
+  }
+});
+cli.command("logs [service]", "Tail PM2 logs for backend, dashboard, or both").option("--lines <count>", "How many recent lines to include", { default: "100" }).action(async (service, options) => {
+  try {
+    await requireProjectRoot(cli.options);
+    const normalizedService = service === "backend" || service === "dashboard" ? service : service ? null : null;
+    if (service && !normalizedService) {
+      throw new Error("Invalid service. Use: waifus logs | waifus logs backend | waifus logs dashboard");
+    }
+    const lineCount = Number.parseInt(options.lines, 10);
+    if (!Number.isFinite(lineCount) || lineCount <= 0) {
+      throw new Error("Invalid --lines value. Use a positive integer.");
+    }
+    const logCommand = getPm2LogCommand(normalizedService, lineCount);
+    await spawnPassthrough(logCommand.command, logCommand.args, process4.cwd());
+  } catch (error) {
+    fail(error);
+  }
+});
+cli.command("open", "Open the local dashboard in the browser").action(async () => {
+  try {
+    await requireProjectRoot(cli.options);
+    await openUrl("http://localhost:3000");
+    success("Opened http://localhost:3000");
+  } catch (error) {
+    fail(error);
+  }
+});
+cli.command("run <service>", "Run backend or dashboard in the foreground").action(async (service) => {
+  try {
+    const projectRoot = await requireProjectRoot(cli.options);
+    if (service !== "backend" && service !== "dashboard") {
+      throw new Error("Invalid service. Use: waifus run backend | waifus run dashboard");
+    }
+    const filterTarget = service === "backend" ? "backend" : "dashboard";
+    await spawnPassthrough("pnpm", ["--filter", filterTarget, "start"], projectRoot, getServiceEnv(service));
+  } catch (error) {
+    fail(error);
+  }
+});
+cli.help();
+cli.version("0.1.0");
+cli.parse(process4.argv);
+function fail(error) {
+  const message = error instanceof Error ? error.message : "Unknown CLI error";
+  console.error(pc2.red(message));
+  process4.exit(1);
+}
+async function listWaifuDocumentFiles(projectRoot) {
+  const paths = getRuntimeLayoutPaths(projectRoot);
+  try {
+    const entries = await fs7.readdir(paths.runtimeWaifusRoot, { withFileTypes: true });
+    return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => path8.join(paths.runtimeWaifusRoot, entry.name));
+  } catch {
+    return [];
+  }
+}
+function legacyConfigFiles(projectRoot) {
+  const paths = getRuntimeLayoutPaths(projectRoot);
+  return [
+    paths.legacyWaifusFile,
+    paths.legacyProvidersFile,
+    paths.legacyChannelsFile,
+    paths.legacyOrchestratorFile,
+    paths.legacyStageManagerFile
+  ];
+}
+async function readConfigFile(filePath) {
+  try {
+    if (filePath.endsWith(".json")) {
+      return await readJsonFile(filePath);
+    }
+    if (filePath.endsWith(".toml")) {
+      return parseToml(await fs7.readFile(filePath, "utf8"));
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function assertNoPendingLegacyMigration(projectRoot) {
+  const runtimeState = await inspectRuntimeState(projectRoot);
+  if (runtimeState.legacyLiveExists && runtimeState.migrationState?.status !== "import_completed") {
+    throw new Error("Legacy live config still exists. Run: waifus migrate-local-config");
+  }
+}
+function findEnvReferences(value) {
+  const references = [];
+  visit(value, (candidate) => {
+    if (typeof candidate !== "string") {
+      return;
+    }
+    const envPrefixMatch = candidate.match(/^env:([A-Z0-9_]+)$/i);
+    if (envPrefixMatch) {
+      references.push({
+        raw: candidate,
+        variableName: envPrefixMatch[1]
+      });
+      return;
+    }
+    const templateMatch = candidate.match(/^\$\{([A-Z0-9_]+)\}$/i);
+    if (templateMatch) {
+      references.push({
+        raw: candidate,
+        variableName: templateMatch[1]
+      });
+    }
+  });
+  return references;
+}
+function visit(value, callback) {
+  callback(value);
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      visit(entry, callback);
+    }
+    return;
+  }
+  if (value && typeof value === "object") {
+    for (const entry of Object.values(value)) {
+      visit(entry, callback);
+    }
+  }
+}
+//# sourceMappingURL=index.js.map