@treeseed/sdk 0.1.1 → 0.3.0

package/dist/operations/services/watch-dev.js

@@ -0,0 +1,284 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { dirname, relative, resolve, sep } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { corePackageRoot, sdkPackageRoot } from "./runtime-tools.js";
+const WATCH_INTERVAL_MS = 900;
+const DEBOUNCE_MS = 350;
+const DEV_RELOAD_FILE = "public/__treeseed/dev-reload.json";
+const PROCESS_SHUTDOWN_TIMEOUT_MS = 5e3;
+const WATCH_BUILD_ROOT = ".local/treeseed-watch";
+const PROCESS_SETTLE_DELAY_MS = 300;
+function isNodeModulesPath(filePath) {
+  return filePath.split(sep).includes("node_modules");
+}
+function isEditablePackageWorkspace() {
+  return !isNodeModulesPath(corePackageRoot);
+}
+function workspaceSdkRoot() {
+  return existsSync(resolve(sdkPackageRoot, "package.json")) ? sdkPackageRoot : null;
+}
+function writeDevReloadStamp(projectRoot) {
+  const outputPath = resolve(projectRoot, DEV_RELOAD_FILE);
+  mkdirSync(dirname(outputPath), { recursive: true });
+  writeFileSync(
+    outputPath,
+    `${JSON.stringify(
+      {
+        buildId: `${Date.now()}`,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      null,
+      2
+    )}
+`,
+    "utf8"
+  );
+}
+function shouldIgnoreWatchPath(filePath, rootPath) {
+  const rel = relative(rootPath, filePath);
+  if (!rel || rel.startsWith(`..${sep}`) || rel === "..") {
+    return false;
+  }
+  const normalized = rel.split(sep).join("/");
+  return normalized === ".git" || normalized.startsWith(".git/") || normalized === "node_modules" || normalized.startsWith("node_modules/") || normalized === ".astro" || normalized.startsWith(".astro/") || normalized === ".wrangler" || normalized.startsWith(".wrangler/") || normalized === ".local" || normalized.startsWith(".local/") || normalized === ".treeseed" || normalized.startsWith(".treeseed/") || normalized === "dist" || normalized.startsWith("dist/") || normalized === "coverage" || normalized.startsWith("coverage/") || normalized === ".dev.vars" || normalized === "books" || normalized.startsWith("books/") || normalized === "__treeseed" || normalized.startsWith("__treeseed/") || normalized.startsWith("public/books/") || normalized.startsWith("public/__treeseed/");
+}
+function collectRootSnapshot(rootPath, snapshot) {
+  if (!existsSync(rootPath)) {
+    return;
+  }
+  const rootStats = statSync(rootPath);
+  if (rootStats.isFile()) {
+    snapshot.set(rootPath, `${rootStats.mtimeMs}:${rootStats.size}`);
+    return;
+  }
+  for (const entry of readdirSync(rootPath, { withFileTypes: true })) {
+    const fullPath = resolve(rootPath, entry.name);
+    if (shouldIgnoreWatchPath(fullPath, rootPath)) {
+      continue;
+    }
+    if (entry.isDirectory()) {
+      collectDirectorySnapshot(fullPath, rootPath, snapshot);
+      continue;
+    }
+    const stats = statSync(fullPath);
+    snapshot.set(fullPath, `${stats.mtimeMs}:${stats.size}`);
+  }
+}
+function collectDirectorySnapshot(directoryPath, rootPath, snapshot) {
+  if (shouldIgnoreWatchPath(directoryPath, rootPath)) {
+    return;
+  }
+  for (const entry of readdirSync(directoryPath, { withFileTypes: true })) {
+    const fullPath = resolve(directoryPath, entry.name);
+    if (shouldIgnoreWatchPath(fullPath, rootPath)) {
+      continue;
+    }
+    if (entry.isDirectory()) {
+      collectDirectorySnapshot(fullPath, rootPath, snapshot);
+      continue;
+    }
+    const stats = statSync(fullPath);
+    snapshot.set(fullPath, `${stats.mtimeMs}:${stats.size}`);
+  }
+}
+function collectSnapshot(entries) {
+  const snapshot = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    collectRootSnapshot(entry.root, snapshot);
+  }
+  return snapshot;
+}
+function diffSnapshots(previousSnapshot, nextSnapshot) {
+  const changed = /* @__PURE__ */ new Set();
+  for (const [filePath, signature] of nextSnapshot.entries()) {
+    if (previousSnapshot.get(filePath) !== signature) {
+      changed.add(filePath);
+    }
+  }
+  for (const filePath of previousSnapshot.keys()) {
+    if (!nextSnapshot.has(filePath)) {
+      changed.add(filePath);
+    }
+  }
+  return [...changed];
+}
+function classifyChanges(changedPaths, watchEntries) {
+  function matchesEntry(filePath, entry) {
+    return filePath === entry.root || filePath.startsWith(`${entry.root}${sep}`);
+  }
+  return {
+    changedPaths,
+    sdkChanged: changedPaths.some(
+      (filePath) => watchEntries.some((entry) => entry.kind === "sdk" && matchesEntry(filePath, entry))
+    ),
+    packageChanged: changedPaths.some(
+      (filePath) => watchEntries.some((entry) => entry.kind === "package" && matchesEntry(filePath, entry))
+    ),
+    tenantChanged: changedPaths.some(
+      (filePath) => watchEntries.some((entry) => entry.kind === "tenant" && matchesEntry(filePath, entry))
+    )
+  };
+}
+function readDevReloadState(projectRoot) {
+  const filePath = resolve(projectRoot, DEV_RELOAD_FILE);
+  if (!existsSync(filePath)) {
+    return null;
+  }
+  try {
+    return JSON.parse(readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function createTenantWatchEntries(tenantRoot) {
+  const entries = [
+    { kind: "tenant", root: resolve(tenantRoot, "src") },
+    { kind: "tenant", root: resolve(tenantRoot, "public") },
+    { kind: "tenant", root: resolve(tenantRoot, "astro.config.ts") },
+    { kind: "tenant", root: resolve(tenantRoot, "treeseed.site.yaml") },
+    { kind: "tenant", root: resolve(tenantRoot, ".env.local") },
+    { kind: "tenant", root: resolve(tenantRoot, ".env.local.example") }
+  ];
+  if (isEditablePackageWorkspace()) {
+    const sdkRoot = workspaceSdkRoot();
+    entries.push(
+      { kind: "package", root: resolve(corePackageRoot, "src") },
+      { kind: "package", root: resolve(corePackageRoot, "scripts") },
+      { kind: "package", root: resolve(corePackageRoot, "services") },
+      { kind: "package", root: resolve(corePackageRoot, "tsconfigs") },
+      { kind: "package", root: resolve(corePackageRoot, "package.json") }
+    );
+    if (sdkRoot) {
+      entries.push(
+        { kind: "sdk", root: resolve(sdkRoot, "src") },
+        { kind: "sdk", root: resolve(sdkRoot, "scripts") },
+        { kind: "sdk", root: resolve(sdkRoot, "package.json") }
+      );
+    }
+  }
+  return entries;
+}
+function startPollingWatch({ watchEntries, onChange }) {
+  let previousSnapshot = collectSnapshot(watchEntries);
+  let queuedPaths = [];
+  let debounceTimer = null;
+  let running = false;
+  let intervalId = null;
+  async function flush() {
+    if (running || queuedPaths.length === 0) {
+      return;
+    }
+    const changedPaths = [...new Set(queuedPaths)];
+    queuedPaths = [];
+    running = true;
+    try {
+      await onChange(classifyChanges(changedPaths, watchEntries));
+    } finally {
+      running = false;
+      if (queuedPaths.length > 0) {
+        debounceTimer = setTimeout(flush, DEBOUNCE_MS);
+      }
+    }
+  }
+  function queueChanges(changedPaths) {
+    if (changedPaths.length === 0) {
+      return;
+    }
+    queuedPaths.push(...changedPaths);
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+    }
+    debounceTimer = setTimeout(flush, DEBOUNCE_MS);
+  }
+  intervalId = setInterval(() => {
+    const nextSnapshot = collectSnapshot(watchEntries);
+    const changedPaths = diffSnapshots(previousSnapshot, nextSnapshot);
+    previousSnapshot = nextSnapshot;
+    queueChanges(changedPaths);
+  }, WATCH_INTERVAL_MS);
+  return () => {
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+    }
+    if (intervalId) {
+      clearInterval(intervalId);
+    }
+  };
+}
+async function stopManagedProcess(child, signal = "SIGTERM") {
+  if (!child || child.exitCode !== null || child.killed) {
+    return;
+  }
+  const groupSignalSupported = process.platform !== "win32" && child.pid && child.spawnargs;
+  let signaled = false;
+  if (groupSignalSupported) {
+    try {
+      process.kill(-child.pid, signal);
+      signaled = true;
+    } catch {
+      signaled = false;
+    }
+  }
+  if (!signaled) {
+    child.kill(signal);
+  }
+  await Promise.race([
+    new Promise((resolve2) => child.once("exit", resolve2)),
+    delay(PROCESS_SHUTDOWN_TIMEOUT_MS)
+  ]);
+  if (child.exitCode === null && !child.killed) {
+    if (groupSignalSupported) {
+      try {
+        process.kill(-child.pid, "SIGKILL");
+      } catch {
+        child.kill("SIGKILL");
+      }
+    } else {
+      child.kill("SIGKILL");
+    }
+    await Promise.race([
+      new Promise((resolve2) => child.once("exit", resolve2)),
+      delay(PROCESS_SHUTDOWN_TIMEOUT_MS)
+    ]);
+  }
+  await delay(PROCESS_SETTLE_DELAY_MS);
+}
+function createWatchBuildPaths(projectRoot) {
+  const watchRoot = resolve(projectRoot, WATCH_BUILD_ROOT);
+  return {
+    watchRoot,
+    stagedDistRoot: resolve(watchRoot, "dist-next"),
+    backupDistRoot: resolve(watchRoot, "dist-prev"),
+    liveDistRoot: resolve(projectRoot, "dist")
+  };
+}
+function swapStagedBuildOutput(projectRoot) {
+  const { watchRoot, stagedDistRoot, backupDistRoot, liveDistRoot } = createWatchBuildPaths(projectRoot);
+  mkdirSync(watchRoot, { recursive: true });
+  rmSync(backupDistRoot, { recursive: true, force: true });
+  if (existsSync(liveDistRoot)) {
+    try {
+      renameSync(liveDistRoot, backupDistRoot);
+    } catch {
+      rmSync(liveDistRoot, { recursive: true, force: true });
+    }
+  }
+  renameSync(stagedDistRoot, liveDistRoot);
+  rmSync(backupDistRoot, { recursive: true, force: true });
+}
+function clearStagedBuildOutput(projectRoot) {
+  const { stagedDistRoot } = createWatchBuildPaths(projectRoot);
+  rmSync(stagedDistRoot, { recursive: true, force: true });
+}
+export {
+  clearStagedBuildOutput,
+  createTenantWatchEntries,
+  createWatchBuildPaths,
+  isEditablePackageWorkspace,
+  readDevReloadState,
+  startPollingWatch,
+  stopManagedProcess,
+  swapStagedBuildOutput,
+  workspaceSdkRoot,
+  writeDevReloadStamp
+};

package/dist/operations/services/workspace-preflight.d.ts

@@ -0,0 +1,40 @@
+export declare function createWranglerCommandEnv(overrides?: {}): {
+    XDG_CONFIG_HOME: string;
+    WRANGLER_SEND_METRICS: string;
+};
+export declare function parseGitHubAuthStatus(): {
+    authenticated: boolean;
+    detail: string;
+};
+export declare function parseWranglerWhoAmI(): {
+    authenticated: boolean;
+    detail: string;
+};
+export declare function parseRailwayWhoAmI(): {
+    authenticated: boolean;
+    detail: string;
+};
+export declare function parseCopilotSessionStatus(): {
+    configured: boolean;
+    detail: string;
+};
+export declare function collectCliPreflight({ cwd, requireAuth }?: {
+    cwd?: string | undefined;
+    requireAuth?: boolean | undefined;
+}): {
+    ok: boolean;
+    requireAuth: boolean;
+    missingCommands: string[];
+    failingAuth: string[];
+    checks: {
+        commands: {
+            [k: string]: {
+                installed: boolean;
+                path: string | null;
+            };
+        };
+        auth: {};
+    };
+};
+export declare function formatCliPreflightReport(report: any): string;
+export declare function writeJsonArtifact(filePath: any, value: any): void;

package/dist/operations/services/workspace-preflight.js

@@ -0,0 +1,165 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { dirname, resolve } from "node:path";
+import { createTempDir } from "./workspace-tools.js";
+function runCapture(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    cwd: options.cwd ?? process.cwd(),
+    env: { ...process.env, ...options.env ?? {} },
+    stdio: "pipe",
+    encoding: "utf8",
+    timeout: options.timeoutMs
+  });
+  return {
+    status: result.status ?? 1,
+    signal: result.signal ?? null,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+    error: result.error?.message ?? null
+  };
+}
+function locateBinary(candidate) {
+  const result = runCapture("bash", ["-lc", `command -v ${candidate}`]);
+  return result.status === 0 ? result.stdout.trim() : null;
+}
+function createWranglerCommandEnv(overrides = {}) {
+  const configHome = createTempDir("treeseed-wrangler-config-");
+  const logDir = resolve(configHome, ".wrangler", "logs");
+  mkdirSync(logDir, { recursive: true });
+  return {
+    XDG_CONFIG_HOME: configHome,
+    WRANGLER_SEND_METRICS: "false",
+    ...overrides
+  };
+}
+function envTokenStatus(keys, label) {
+  const foundKey = keys.find((key) => {
+    const value = process.env[key];
+    return typeof value === "string" && value.trim().length > 0;
+  }) ?? null;
+  return {
+    ready: Boolean(foundKey),
+    detail: foundKey ? `${label} token detected from ${foundKey}.` : `${label} token is not configured. Set ${keys.join(" or ")}.`,
+    source: foundKey ? "env" : "missing"
+  };
+}
+function parseGitHubAuthStatus() {
+  return {
+    authenticated: envTokenStatus(["GH_TOKEN"], "GitHub").ready,
+    detail: envTokenStatus(["GH_TOKEN"], "GitHub").detail
+  };
+}
+function parseWranglerWhoAmI() {
+  return {
+    authenticated: envTokenStatus(["CLOUDFLARE_API_TOKEN"], "Cloudflare").ready,
+    detail: envTokenStatus(["CLOUDFLARE_API_TOKEN"], "Cloudflare").detail
+  };
+}
+function parseRailwayWhoAmI() {
+  return {
+    authenticated: envTokenStatus(["RAILWAY_API_TOKEN"], "Railway").ready,
+    detail: envTokenStatus(["RAILWAY_API_TOKEN"], "Railway").detail
+  };
+}
+function parseCopilotSessionStatus() {
+  const status = envTokenStatus(["GH_TOKEN"], "GitHub");
+  return {
+    configured: status.ready,
+    detail: status.ready ? "GitHub token detected from GH_TOKEN for Copilot-backed workflows." : "GitHub token is not configured. Set GH_TOKEN for Copilot-backed workflows."
+  };
+}
+function collectCliPreflight({ cwd = process.cwd(), requireAuth = false } = {}) {
+  const binaries = {
+    git: locateBinary("git"),
+    npm: locateBinary("npm"),
+    gh: locateBinary("gh"),
+    wrangler: locateBinary("wrangler"),
+    railway: locateBinary("railway"),
+    copilot: locateBinary("copilot")
+  };
+  const checks = {
+    commands: Object.fromEntries(
+      Object.entries(binaries).map(([name, path]) => [name, {
+        installed: Boolean(path),
+        path
+      }])
+    ),
+    auth: {}
+  };
+  if (binaries.gh) {
+    checks.auth.gh = parseGitHubAuthStatus();
+  } else {
+    checks.auth.gh = { authenticated: false, detail: "GitHub CLI is not installed." };
+  }
+  if (binaries.wrangler) {
+    checks.auth.wrangler = parseWranglerWhoAmI();
+  } else {
+    checks.auth.wrangler = { authenticated: false, detail: "Wrangler CLI is not installed." };
+  }
+  if (binaries.railway) {
+    checks.auth.railway = parseRailwayWhoAmI();
+  } else {
+    checks.auth.railway = { authenticated: false, detail: "Railway CLI is not installed." };
+  }
+  if (binaries.copilot) {
+    checks.auth.copilot = parseCopilotSessionStatus();
+  } else {
+    checks.auth.copilot = { configured: false, detail: "Copilot CLI is not installed." };
+  }
+  const missingCommands = Object.entries(checks.commands).filter(([, value]) => !value.installed).map(([name]) => name);
+  const failingAuth = [];
+  if (requireAuth) {
+    if (!checks.auth.gh?.authenticated) failingAuth.push("gh");
+    if (!checks.auth.wrangler?.authenticated) failingAuth.push("wrangler");
+    if (!checks.auth.railway?.authenticated) failingAuth.push("railway");
+  }
+  return {
+    ok: missingCommands.length === 0 && failingAuth.length === 0,
+    requireAuth,
+    missingCommands,
+    failingAuth,
+    checks
+  };
+}
+function formatCliPreflightReport(report) {
+  const lines = [
+    "Treeseed preflight summary",
+    `Status: ${report.ok ? "ok" : "failed"}`,
+    `Require auth: ${report.requireAuth ? "yes" : "no"}`,
+    "Commands:"
+  ];
+  for (const [name, info] of Object.entries(report.checks.commands)) {
+    lines.push(`- ${name}: ${info.installed ? `installed (${info.path})` : "missing"}`);
+  }
+  lines.push("Auth/session:");
+  lines.push(`- gh: ${report.checks.auth.gh?.authenticated ? "authenticated" : "not authenticated"}`);
+  lines.push(`  ${report.checks.auth.gh?.detail ?? ""}`.trimEnd());
+  lines.push(`- wrangler: ${report.checks.auth.wrangler?.authenticated ? "authenticated" : "not authenticated"}`);
+  lines.push(`  ${report.checks.auth.wrangler?.detail ?? ""}`.trimEnd());
+  lines.push(`- railway: ${report.checks.auth.railway?.authenticated ? "authenticated" : "not authenticated"}`);
+  lines.push(`  ${report.checks.auth.railway?.detail ?? ""}`.trimEnd());
+  lines.push(`- copilot: ${report.checks.auth.copilot?.configured ? "configured" : "not configured"}`);
+  lines.push(`  ${report.checks.auth.copilot?.detail ?? ""}`.trimEnd());
+  if (report.missingCommands.length > 0) {
+    lines.push(`Missing commands: ${report.missingCommands.join(", ")}`);
+  }
+  if (report.failingAuth.length > 0) {
+    lines.push(`Auth failures: ${report.failingAuth.join(", ")}`);
+  }
+  return lines.filter(Boolean).join("\n");
+}
+function writeJsonArtifact(filePath, value) {
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+export {
+  collectCliPreflight,
+  createWranglerCommandEnv,
+  formatCliPreflightReport,
+  parseCopilotSessionStatus,
+  parseGitHubAuthStatus,
+  parseRailwayWhoAmI,
+  parseWranglerWhoAmI,
+  writeJsonArtifact
+};

package/dist/operations/services/workspace-save.d.ts

@@ -0,0 +1,42 @@
+export declare const MERGE_CONFLICT_EXIT_CODE = 12;
+export declare function incrementPatchVersion(version: any): string;
+export declare function incrementVersion(version: any, level?: string): string;
+export declare function planWorkspaceVersionChanges(root?: any): {
+    packages: any[];
+    publishable: Set<any>;
+    bumped: Set<any>;
+    touched: Set<unknown>;
+};
+export declare function applyWorkspaceVersionChanges(plan: any): any;
+export declare function planWorkspaceReleaseBump(level?: string, root?: any): {
+    packages: any[];
+    touched: Set<unknown>;
+    versions: Map<any, any>;
+    level: string;
+};
+export declare function repoRoot(cwd?: any): string;
+export declare function currentBranch(repoDir: any): string;
+export declare function originRemoteUrl(repoDir: any): string;
+export declare function gitStatusPorcelain(repoDir: any): string;
+export declare function hasMeaningfulChanges(repoDir: any): boolean;
+export declare function countConflictMarkers(source: any): {
+    start: any;
+    middle: any;
+    end: any;
+};
+export declare function collectMergeConflictReport(repoDir: any): {
+    branch: string;
+    rebaseInProgress: boolean;
+    conflictedFiles: string[];
+    status: string;
+    perFile: {
+        filePath: string;
+        markers: {
+            start: any;
+            middle: any;
+            end: any;
+        };
+        diff: string;
+    }[];
+};
+export declare function formatMergeConflictReport(report: any, repoDir: any, targetBranch?: string): string;