@altimateai/altimate-code 0.8.7 → 0.8.10

package/CHANGELOG.md

@@ -5,6 +5,59 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.8.10] - 2026-06-22
+
+### Fixed
+
+- **The daily date no longer invalidates the cached system prompt across midnight.** The volatile "Today's date" line was the first entry in the cache-controlled system prefix, so a session left open across midnight within the cache TTL dropped its entire cached system prompt and paid to rebuild it. The date now rides the trailing user message — off the long-lived system-prefix cache and onto the rolling per-turn breakpoint that is rewritten every turn anyway — so the cached system bytes stay date-invariant and the agent still receives today's date each turn. (#950, fixes #949)
+
+### Internal
+
+- **The Windows installer Pester suite is deterministic on the updated `windows-latest` runner.** The harness now applies `PROCESSOR_*` overrides inside the child `pwsh` session instead of relying on Process-scope inheritance, which the new runner image re-initialized for the loader-managed `PROCESSOR_ARCHITECTURE` (it arrived blank → a spurious `Unsupported OS/Arch` failure). Test-only: the shipped `install.ps1` and the v0.8.9 binaries are unaffected — real users always have a populated `PROCESSOR_ARCHITECTURE`. (#959, fixes #958)
+- **Added a v0.8.10 adversarial + coverage suite** that closes the prior test gap on the date fix — it exercises the trailing-user-message path (date reaches the model, only the last user turn is tagged, no accumulation across turns, survives an all-ignored user turn) plus a static regression guard on the Windows installer harness. (#950, #959)
+
+## [0.8.9] - 2026-06-19
+
+### Fixed
+
+- **The non-interactive `run` guard no longer mis-handles a blank env var.** A blank/whitespace `ALTIMATE_NON_INTERACTIVE=` is now treated as unset, so it can't silently reintroduce the headless `run` hang that #937 fixed. (#937 follow-up)
+- **Session transcript boolean query flags accept the common falsey strings.** `thinking`, `toolDetails`, and `assistantMetadata` now treat `false`/`0`/`no`/`off` (case-insensitive) as false, not just the literal `"false"`. (#941 follow-up)
+- **Writing an MCP server entry refuses to clobber an unparseable config** (detected via `parse()` with an error sink, not the error-tolerant `parseTree()`), and `updatedAt` is preserved through config normalization so the datamate reconnect signal survives. (#893 follow-up)
+- **dbt error bubbling strips the full ANSI escape family** (cursor/erase sequences from progress spinners), not just SGR color codes. (#933 follow-up)
+
+### Changed
+
+- **The headless `serve` startup upgrade check is jittered** (base + random, ~1–6s) so a fleet restarting together doesn't stampede the unauthenticated GitHub releases API in the same instant. (#940 follow-up)
+
+### Internal
+
+- **Diverged upstream constants are wrapped in `altimate_change` markers** (`DEFAULT_CHUNK_TIMEOUT`, the question-tool `output` field) so they survive upstream merges. (#844, #937)
+- **Added a v0.8.9 adversarial test suite** covering the shipping code and the review fixes under hostile input (question-tool env matrix, MCP config parse-guard, startup-upgrade fail-safety + jitter).
+
+## [0.8.8] - 2026-06-19
+
+### Added
+
+- **Windows now has a one-line PowerShell installer.** `irm https://www.altimate.sh/install.ps1 | iex` downloads the standalone binary from GitHub releases (AVX2-aware, with a baseline fallback), adds it to your user `PATH`, and supports `-Version`, `-NoPathUpdate`, and `-ForceBaseline`. `altimate upgrade` uses the same path on Windows. (#930)
+- **IDE-aware datamate transport, MCP enabled-state persistence, and a `/mcps` command.** The active IDE's `mcp.json` datamate entry/URL is mirrored into `altimate-code.json` and reconnected when it changes; enabled/disabled state for MCP servers now persists to disk; `/mcps` lists and toggles servers; project `mcp.json` files are discovered recursively (project-scoped servers are discovered disabled, never auto-connected). (#893)
+- **Session transcript REST endpoint for the datamates extension.** `GET /session/:id/transcript` returns the full conversation as formatted Markdown, with `thinking`, `toolDetails`, and `assistantMetadata` query flags. (#941)
+
+### Changed
+
+- **Headless `serve` now checks for and applies updates on startup.** When `autoupdate` is unset (the default) and a supported install method is present, `serve` performs a one-shot, best-effort self-upgrade shortly after start. It never restarts the running process and can never crash `serve` (errors are swallowed). Opt out with `autoupdate: false` or `"notify"` in config, or `OPENCODE_DISABLE_AUTOUPDATE=1`. (#940)
+- **The per-chunk streaming watchdog timeout was raised from 2 minutes to 5 minutes** so slow warehouse/LLM streams are not aborted prematurely. (#844)
+
+### Fixed
+
+- **`dbt show`/`compile` failures now surface the real dbt error** instead of a generic "Could not parse", with inline SQL redacted from the message so secrets/PII don't leak into logs. (#933)
+- **The question tool no longer hangs in non-interactive contexts.** `altimate run` is detected as headless and returns "Unanswered" (letting the agent decide) rather than blocking forever; `ALTIMATE_AUTO_ANSWER=first|last|<label>` can pre-answer. (#937)
+- **Windows release archives are verified by checksum in both installers** before extraction, and latest-version resolution is more resilient to transient fetch failures. (#942, #946)
+
+### Internal
+
+- **`serve` logs the trace directory on startup** so operators can find session traces. (#929)
+- **Added a release-validation regression suite** covering the merged PRs. (#952)
+
 ## [0.8.7] - 2026-06-10
 
 ### Added

package/dbt-tools/dist/index.js

@@ -321,16 +321,25 @@ function getDbt() {
   }
   return resolvedDbt;
 }
+function toExecFileError(e) {
+  if (e instanceof Error)
+    return e;
+  return new Error(String(e));
+}
 function run2(args) {
   const dbt2 = getDbt();
   const env = buildDbtEnv(dbt2);
   const cwd = globalOptions.projectRoot ?? process.cwd();
   return new Promise((resolve4, reject2) => {
     execFile(dbt2.path, args, { timeout: 120000, maxBuffer: 10 * 1024 * 1024, env, cwd }, (err, stdout, stderr) => {
-      if (err)
-        reject2(err);
-      else
+      if (err) {
+        const execErr = err;
+        execErr.stdout = stdout;
+        execErr.stderr = stderr;
+        reject2(execErr);
+      } else {
         resolve4({ stdout, stderr });
+      }
     });
   });
 }
@@ -392,7 +401,7 @@ function looksLikeRowData(val) {
   }
 }
 function stripAnsi(text) {
-  return text.replace(/\x1b\[[0-9;]*m/g, "");
+  return text.replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "");
 }
 function parseAsciiTable(text) {
   const cleaned = stripAnsi(text);
@@ -439,41 +448,43 @@ async function execDbtShow(sql, limit) {
   const args = ["show", "--inline", sql, "--output", "json", "--log-format", "json"];
   if (limit !== undefined)
     args.push("--limit", String(limit));
-  let lines;
+  let primaryRunError;
+  let lines = [];
   try {
     const { stdout } = await run2(args);
     lines = parseJsonLines(stdout);
-  } catch {
-    lines = [];
-  }
-  const previewLine = lines.find((l) => l.data?.preview) ?? lines.find((l) => l.data?.rows) ?? lines.find((l) => l.result?.preview) ?? lines.find((l) => l.result?.rows);
-  const sqlLine = lines.find((l) => l.data?.sql) ?? lines.find((l) => l.data?.compiled_sql) ?? lines.find((l) => l.result?.sql);
-  if (previewLine) {
-    const preview = previewLine.data?.preview ?? previewLine.data?.rows ?? previewLine.result?.preview ?? previewLine.result?.rows;
-    let rows;
-    if (typeof preview === "string") {
-      const parsed = safeJsonParse(preview);
-      if (Array.isArray(parsed)) {
-        rows = parsed;
+  } catch (e) {
+    primaryRunError = toExecFileError(e);
+  }
+  if (!primaryRunError) {
+    const previewLine = lines.find((l) => l.data?.preview) ?? lines.find((l) => l.data?.rows) ?? lines.find((l) => l.result?.preview) ?? lines.find((l) => l.result?.rows);
+    const sqlLine = lines.find((l) => l.data?.sql) ?? lines.find((l) => l.data?.compiled_sql) ?? lines.find((l) => l.result?.sql);
+    if (previewLine) {
+      const preview = previewLine.data?.preview ?? previewLine.data?.rows ?? previewLine.result?.preview ?? previewLine.result?.rows;
+      let rows;
+      if (typeof preview === "string") {
+        const parsed = safeJsonParse(preview);
+        rows = Array.isArray(parsed) ? parsed : [];
+      } else if (Array.isArray(preview)) {
+        rows = preview;
       } else {
         rows = [];
       }
-    } else {
-      rows = preview;
-    }
-    const columnNames = rows.length > 0 && rows[0] ? Object.keys(rows[0]) : [];
-    const compiledSql = sqlLine?.data?.sql ?? sqlLine?.data?.compiled_sql ?? sqlLine?.result?.sql ?? sql;
-    return { columnNames, columnTypes: columnNames.map(() => "string"), data: rows, rawSql: sql, compiledSql };
-  }
-  for (const line of lines) {
-    const found = deepFind(line, (val) => looksLikeRowData(val));
-    if (found) {
-      const rows = typeof found === "string" ? JSON.parse(found) : found;
       const columnNames = rows.length > 0 && rows[0] ? Object.keys(rows[0]) : [];
-      const compiledSql = deepFind(line, (val) => looksLikeSql(val)) ?? sql;
+      const compiledSql = sqlLine?.data?.sql ?? sqlLine?.data?.compiled_sql ?? sqlLine?.result?.sql ?? sql;
       return { columnNames, columnTypes: columnNames.map(() => "string"), data: rows, rawSql: sql, compiledSql };
     }
+    for (const line of lines) {
+      const found = deepFind(line, (val) => looksLikeRowData(val));
+      if (found) {
+        const rows = typeof found === "string" ? JSON.parse(found) : found;
+        const columnNames = rows.length > 0 && rows[0] ? Object.keys(rows[0]) : [];
+        const compiledSql = deepFind(line, (val) => looksLikeSql(val)) ?? sql;
+        return { columnNames, columnTypes: columnNames.map(() => "string"), data: rows, rawSql: sql, compiledSql };
+      }
+    }
   }
+  let plainRunError;
   try {
     const plainArgs = ["show", "--inline", sql];
     if (limit !== undefined)
@@ -489,62 +500,135 @@ async function execDbtShow(sql, limit) {
         compiledSql: sql
       };
     }
-  } catch {}
+  } catch (e) {
+    plainRunError = toExecFileError(e);
+  }
+  if (primaryRunError) {
+    const errorLogLines = parseJsonLines(primaryRunError.stdout?.toString() ?? "");
+    const realError = extractDbtError(errorLogLines, primaryRunError, plainRunError);
+    if (realError) {
+      const hasDbtCategoryPrefix = /^(Compilation|Database|Runtime|Parsing|Validation|Dependency)\s+Error\b/.test(realError);
+      throw new Error(hasDbtCategoryPrefix ? realError : `dbt show failed: ${realError}`);
+    }
+  }
+  if (plainRunError) {
+    const fallback = extractDbtError([], undefined, plainRunError) ?? fallbackExitMessage(undefined, plainRunError) ?? "unknown error";
+    throw new Error(`Could not parse dbt show JSON output, and plain-text fallback failed: ${fallback}`);
+  }
   throw new Error("Could not parse dbt show output in any format (JSON, heuristic, or plain text). " + `Got ${lines.length} JSON lines.`);
 }
+function extractDbtError(lines, primary, plain) {
+  if (!primary && !plain)
+    return;
+  const errorMessages = lines.map((l) => {
+    const line = l;
+    const isError = line.info?.level === "error" || line.level === "error";
+    if (!isError)
+      return;
+    return line.info?.msg ?? line.msg;
+  }).filter((m) => typeof m === "string" && m.trim().length > 0);
+  const structuredMsg = errorMessages.at(-1);
+  const primaryStderr = primary?.stderr?.toString().trim();
+  const plainStderr = plain?.stderr?.toString().trim();
+  const chosen = (structuredMsg && structuredMsg.length > 0 ? structuredMsg : undefined) ?? (primaryStderr && primaryStderr.length > 0 ? primaryStderr : undefined) ?? (plainStderr && plainStderr.length > 0 ? plainStderr : undefined) ?? fallbackExitMessage(primary, plain);
+  return chosen ? stripAnsi(chosen) : undefined;
+}
+function fallbackExitMessage(primary, plain) {
+  const err = primary ?? plain;
+  if (!err)
+    return;
+  const looksLikeCommandFailed = typeof err.message === "string" && err.message.startsWith("Command failed:");
+  if (!looksLikeCommandFailed)
+    return err.message;
+  if (typeof err.code === "number")
+    return `dbt exited with status ${err.code}`;
+  if (err.signal)
+    return `dbt killed by signal ${err.signal}`;
+  if (typeof err.code === "string")
+    return `dbt failed: ${err.code}`;
+  return "dbt failed (no exit code reported)";
+}
+function bubbleDbtError(label, primary, plain) {
+  const errorLogLines = primary?.stdout ? parseJsonLines(primary.stdout.toString()) : [];
+  const real = extractDbtError(errorLogLines, primary, plain);
+  if (real) {
+    const hasDbtCategoryPrefix = /^(Compilation|Database|Runtime|Parsing|Validation|Dependency)\s+Error\b/.test(real);
+    return hasDbtCategoryPrefix ? real : `${label}: ${real}`;
+  }
+  return `${label}: ${fallbackExitMessage(primary, plain) ?? "unknown error"}`;
+}
 async function execDbtCompile(model) {
   const args = ["compile", "--select", model, "--output", "json", "--log-format", "json"];
-  let lines;
+  let lines = [];
+  let primaryRunError;
   try {
     const { stdout } = await run2(args);
     lines = parseJsonLines(stdout);
-  } catch {
-    lines = [];
+  } catch (e) {
+    primaryRunError = toExecFileError(e);
   }
-  const sql = findCompiledSql(lines);
-  if (sql)
-    return { sql };
-  for (const line of lines) {
-    const found = deepFind(line, (val) => looksLikeSql(val));
-    if (found)
-      return { sql: found };
+  if (!primaryRunError) {
+    const sql = findCompiledSql(lines);
+    if (sql)
+      return { sql };
+    for (const line of lines) {
+      const found = deepFind(line, (val) => looksLikeSql(val));
+      if (found)
+        return { sql: found };
+    }
   }
+  let manifestRunError;
   try {
     await run2(["compile", "--select", model]);
-  } catch {}
+  } catch (e) {
+    manifestRunError = toExecFileError(e);
+  }
   const fromManifest = readCompiledFromManifest(model);
   if (fromManifest)
     return { sql: fromManifest };
+  let plainRunError;
   try {
     const { stdout: plainOut } = await run2(["compile", "--select", model]);
     return { sql: plainOut.trim() };
   } catch (e) {
-    throw new Error(`Could not compile model '${model}' in any format (JSON, heuristic, or manifest). ` + `Last error: ${e instanceof Error ? e.message : String(e)}`);
+    plainRunError = toExecFileError(e);
+  }
+  if (primaryRunError || plainRunError || manifestRunError) {
+    throw new Error(bubbleDbtError("dbt compile failed", primaryRunError, plainRunError ?? manifestRunError));
   }
+  throw new Error(`Could not compile model '${model}' in any format (JSON, heuristic, or manifest).`);
 }
 async function execDbtCompileInline(sql, _model) {
   const args = ["compile", "--inline", sql, "--output", "json", "--log-format", "json"];
-  let lines;
+  let lines = [];
+  let primaryRunError;
   try {
     const { stdout } = await run2(args);
     lines = parseJsonLines(stdout);
-  } catch {
-    lines = [];
+  } catch (e) {
+    primaryRunError = toExecFileError(e);
   }
-  const compiled = findCompiledSql(lines);
-  if (compiled)
-    return { sql: compiled };
-  for (const line of lines) {
-    const found = deepFind(line, (val) => looksLikeSql(val));
-    if (found)
-      return { sql: found };
+  if (!primaryRunError) {
+    const compiled = findCompiledSql(lines);
+    if (compiled)
+      return { sql: compiled };
+    for (const line of lines) {
+      const found = deepFind(line, (val) => looksLikeSql(val));
+      if (found)
+        return { sql: found };
+    }
   }
+  let plainRunError;
   try {
     const { stdout: plainOut } = await run2(["compile", "--inline", sql]);
     return { sql: plainOut.trim() };
   } catch (e) {
-    throw new Error(`Could not compile inline SQL in any format (JSON, heuristic, or plain text). ` + `Last error: ${e instanceof Error ? e.message : String(e)}`);
+    plainRunError = toExecFileError(e);
+  }
+  if (primaryRunError || plainRunError) {
+    throw new Error(bubbleDbtError("dbt compile inline failed", primaryRunError, plainRunError));
   }
+  throw new Error("Could not compile inline SQL in any format (JSON, heuristic, or plain text).");
 }
 function findCompiledSql(lines) {
   const compiledLine = lines.find((l) => l.data?.compiled) ?? lines.find((l) => l.data?.compiled_code) ?? lines.find((l) => l.result?.node?.compiled_code) ?? lines.find((l) => l.result?.compiled_code) ?? lines.find((l) => l.data?.compiled_sql);

package/package.json

@@ -7,20 +7,20 @@
   "scripts": {
     "postinstall": "bun ./postinstall.mjs || node ./postinstall.mjs"
   },
-  "version": "0.8.7",
+  "version": "0.8.10",
   "license": "MIT",
   "dependencies": {
     "@altimateai/altimate-core": "0.5.1"
   },
   "optionalDependencies": {
-    "@altimateai/altimate-code-linux-x64-baseline": "0.8.7",
-    "@altimateai/altimate-code-windows-x64": "0.8.7",
-    "@altimateai/altimate-code-linux-x64": "0.8.7",
-    "@altimateai/altimate-code-darwin-x64": "0.8.7",
-    "@altimateai/altimate-code-darwin-x64-baseline": "0.8.7",
-    "@altimateai/altimate-code-darwin-arm64": "0.8.7",
-    "@altimateai/altimate-code-windows-x64-baseline": "0.8.7",
-    "@altimateai/altimate-code-linux-arm64": "0.8.7"
+    "@altimateai/altimate-code-linux-x64-baseline": "0.8.10",
+    "@altimateai/altimate-code-windows-x64": "0.8.10",
+    "@altimateai/altimate-code-linux-x64": "0.8.10",
+    "@altimateai/altimate-code-darwin-x64": "0.8.10",
+    "@altimateai/altimate-code-darwin-x64-baseline": "0.8.10",
+    "@altimateai/altimate-code-darwin-arm64": "0.8.10",
+    "@altimateai/altimate-code-windows-x64-baseline": "0.8.10",
+    "@altimateai/altimate-code-linux-arm64": "0.8.10"
   },
   "peerDependencies": {
     "pg": ">=8",