@odla-ai/cli 0.41.0 → 0.41.1

package/bin/odla-ai.js

@@ -1,20 +1,22 @@
 #!/usr/bin/env node
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, statSync } from "node:fs";
 import { spawnSync } from "node:child_process";
 import { dirname, join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { workspaceBuildOrder } from "./workspace-build.js";
+import { firstStaleWorkspace, staleBuildNotice } from "./stale-build.js";
 
 const packageRoot = join(dirname(fileURLToPath(import.meta.url)), "..");
 const builtEntry = join(packageRoot, "dist", "bin.js");
+const workspaceRoot = join(packageRoot, "..", "..");
+const rootManifestPath = join(workspaceRoot, "package.json");
+const rootManifest = existsSync(rootManifestPath)
+  ? JSON.parse(readFileSync(rootManifestPath, "utf8"))
+  : null;
+const inWorkspace = rootManifest?.name === "odla-ai" && rootManifest.private === true;
 
 if (!existsSync(builtEntry)) {
-  const workspaceRoot = join(packageRoot, "..", "..");
-  const rootManifestPath = join(workspaceRoot, "package.json");
-  const rootManifest = existsSync(rootManifestPath)
-    ? JSON.parse(readFileSync(rootManifestPath, "utf8"))
-    : null;
-  if (rootManifest?.name !== "odla-ai" || rootManifest.private !== true) {
+  if (!inWorkspace) {
     throw new Error("odla-ai CLI build is missing; reinstall @odla-ai/cli from npm");
   }
 
@@ -28,6 +30,14 @@ if (!existsSync(builtEntry)) {
   );
   if (child.error) throw child.error;
   if (child.status !== 0) process.exit(child.status ?? 1);
+} else if (inWorkspace) {
+  // stderr, never stdout: every --json command stays parseable.
+  const stale = firstStaleWorkspace(
+    workspaceRoot,
+    workspaceBuildOrder(workspaceRoot),
+    statSync(builtEntry).mtimeMs,
+  );
+  if (stale) console.error(staleBuildNotice(stale));
 }
 
 await import(pathToFileURL(builtEntry).href);

package/bin/stale-build.d.ts

@@ -0,0 +1,16 @@
+/** A workspace whose sources are newer than the built entry about to run. */
+export interface StaleWorkspace {
+  workspace: string;
+  file: string;
+}
+
+/** The first workspace in `workspaceNames` whose `src` is newer than
+ * `builtAtMs`, or null when the build is current or the tree is unreadable. */
+export declare function firstStaleWorkspace(
+  root: string,
+  workspaceNames: readonly string[],
+  builtAtMs: number,
+): StaleWorkspace | null;
+
+/** The one-line stderr notice naming the stale workspace and the way out. */
+export declare function staleBuildNotice(stale: StaleWorkspace): string;

package/bin/stale-build.js

@@ -0,0 +1,77 @@
+// A workspace checkout runs the CLI through a symlink into packages/cli, so
+// `npx odla-ai` answers from whatever was last built — which can be a day older
+// than the source sitting next to it, with nothing saying so. That is not a
+// cosmetic problem: an agent reads the stale output, believes it, and reasons
+// from a surface that no longer exists. The launcher already handles "not built
+// at all"; this handles "built, but behind".
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { workspacePackages } from "./workspace-build.js";
+
+/** Directories that never hold sources worth comparing. */
+const SKIP = new Set(["node_modules", "dist", "js", ".turbo", ".wrangler"]);
+
+/** First file under `dir` modified after `builtAtMs`, or null. Depth-first and
+ * early-exiting: the answer is "is anything newer", not "what is newest". */
+function firstNewerFile(dir, builtAtMs) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") || SKIP.has(entry.name)) continue;
+    const path = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      const found = firstNewerFile(path, builtAtMs);
+      if (found) return found;
+      continue;
+    }
+    try {
+      if (statSync(path).mtimeMs > builtAtMs) return path;
+    } catch {
+      // A file that vanished mid-walk is not evidence of staleness.
+    }
+  }
+  return null;
+}
+
+/**
+ * The first workspace whose sources are newer than the built entry about to be
+ * run, or null when the build is current.
+ *
+ * Checks the CLI's whole internal dependency closure, not just its own `src`:
+ * a stale `@odla-ai/db` breaks the CLI just as thoroughly, and reports itself
+ * as a missing export rather than as a stale build.
+ *
+ * Returns null rather than throwing for anything unreadable — a diagnostic
+ * must never be the reason a command fails.
+ */
+export function firstStaleWorkspace(root, workspaceNames, builtAtMs) {
+  try {
+    const packages = workspacePackages(root);
+    for (const name of workspaceNames) {
+      const entry = packages.get(name);
+      if (!entry) continue;
+      // A published install ships `dist` and no `src`, so its absence is how we
+      // know this is not a source checkout rather than a stale one.
+      const source = join(entry.dir, "src");
+      if (!existsSync(source)) continue;
+      const file = firstNewerFile(source, builtAtMs);
+      if (file) return { workspace: name, file };
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+
+/** The one line a stale workspace build is worth, and what ends it. */
+export function staleBuildNotice(stale) {
+  return (
+    `odla-ai: running a stale build — ${stale.workspace} source is newer than ` +
+    "the built CLI, so this output can describe code that no longer exists. " +
+    "Run `npm run build`."
+  );
+}

package/bin/workspace-build.d.ts

@@ -1,2 +1,7 @@
 /** Return buildable internal dependencies in dependency-first order. */
 export declare function workspaceBuildOrder(root: string): string[];
+
+/** Every workspace in the checkout, by package name, with its directory. */
+export declare function workspacePackages(
+  root: string,
+): Map<string, { dir: string; manifest: Record<string, unknown> }>;

package/bin/workspace-build.js

@@ -3,8 +3,10 @@ import { join } from "node:path";
 
 const manifestAt = (path) => JSON.parse(readFileSync(path, "utf8"));
 
-/** Return buildable internal dependencies in dependency-first order. */
-export function workspaceBuildOrder(root) {
+/** Every workspace in the checkout, by package name, with the directory it
+ * lives in. Shared so the launcher's build order and its staleness check agree
+ * on what a workspace is and where its sources are. */
+export function workspacePackages(root) {
   const rootManifest = manifestAt(join(root, "package.json"));
   const workspaces = new Map();
   for (const pattern of rootManifest.workspaces ?? []) {
@@ -13,12 +15,22 @@ export function workspaceBuildOrder(root) {
     if (!existsSync(parent)) continue;
     for (const entry of readdirSync(parent, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
-      const manifestPath = join(parent, entry.name, "package.json");
+      const dir = join(parent, entry.name);
+      const manifestPath = join(dir, "package.json");
       if (!existsSync(manifestPath)) continue;
       const manifest = manifestAt(manifestPath);
-      if (manifest.name) workspaces.set(manifest.name, manifest);
+      if (manifest.name) workspaces.set(manifest.name, { dir, manifest });
     }
   }
+  return workspaces;
+}
+
+/** Return buildable internal dependencies in dependency-first order. */
+export function workspaceBuildOrder(root) {
+  const packages = workspacePackages(root);
+  const workspaces = new Map(
+    [...packages].map(([name, entry]) => [name, entry.manifest]),
+  );
 
   const visited = new Set();
   const order = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@odla-ai/cli",
-  "version": "0.41.0",
+  "version": "0.41.1",
   "description": "Agent-operable CLI for odla provisioning, calendar consent and connection lifecycle, System AI administration, Worker secrets, security jobs, and smoke checks.",
   "license": "MIT",
   "homepage": "https://odla.ai/docs/packages/cli",