mixdog 0.9.0 → 0.9.2

package/src/runtime/shared/transcript-writer.mjs

@@ -0,0 +1,129 @@
+/**
+ * Transcript writer for remote (Discord) mode.
+ *
+ * The channel worker's OutputForwarder tails a newline-delimited JSON
+ * transcript and forwards the "surface" view (assistant text + one-line tool
+ * summaries) to Discord. Nothing wrote that file for standalone sessions, so
+ * remote outbound never worked. This module writes the JSONL in the exact
+ * schema the forwarder parses (see channels/lib/output-forwarder.mjs
+ * extractNewText) plus a session record the forwarder's discovery reads
+ * (channels/lib/session-discovery.mjs readSessionRecord).
+ *
+ * All writes are best-effort: a failure must never break the ask() turn. We
+ * log the FIRST occurrence of each distinct failure string to stderr (prefix
+ * `mixdog: transcript-writer: `) and suppress duplicates so a broken path
+ * cannot spam the terminal.
+ */
+import { appendFileSync, mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+
+// Byte-identical to cwdToProjectSlug() in
+// src/runtime/channels/lib/session-discovery.mjs. Inlined to avoid a
+// shared -> channels import coupling; keep the two in sync if either changes.
+function cwdToProjectSlug(cwd) {
+  return resolve(cwd).replace(/\\/g, '/').replace(/^([A-Za-z]):/, '$1-').replace(/\//g, '-');
+}
+
+export function createTranscriptWriter({ mixdogHome, sessionId, cwd, pid } = {}) {
+  if (!mixdogHome) throw new Error('transcript-writer: mixdogHome is required');
+  if (!sessionId) throw new Error('transcript-writer: sessionId is required');
+  if (!cwd) throw new Error('transcript-writer: cwd is required');
+
+  const resolvedCwd = resolve(cwd);
+  const projectDir = join(mixdogHome, 'projects', cwdToProjectSlug(resolvedCwd));
+  const transcriptPath = join(projectDir, `${sessionId}.jsonl`);
+  const sessionRecordPath = join(mixdogHome, 'sessions', `${pid ?? process.pid}.json`);
+  const startedAt = Date.now();
+
+  // Repeated-failure guard: log the first time each distinct message is seen,
+  // then stay quiet so a persistently-broken path does not flood stderr.
+  const seenErrors = new Set();
+  function logOnce(err) {
+    const msg = err && err.message ? err.message : String(err);
+    if (seenErrors.has(msg)) return;
+    seenErrors.add(msg);
+    try { process.stderr.write(`mixdog: transcript-writer: ${msg}\n`); } catch { /* stderr broken */ }
+  }
+
+  let projectDirReady = false;
+  function ensureProjectDir() {
+    if (projectDirReady) return;
+    try {
+      mkdirSync(projectDir, { recursive: true });
+      projectDirReady = true;
+    } catch (err) {
+      logOnce(err);
+    }
+  }
+
+  function appendLine(entry) {
+    ensureProjectDir();
+    try {
+      appendFileSync(transcriptPath, `${JSON.stringify(entry)}\n`);
+    } catch (err) {
+      logOnce(err);
+    }
+  }
+
+  function writeSessionRecord() {
+    try {
+      mkdirSync(dirname(sessionRecordPath), { recursive: true });
+      writeFileSync(sessionRecordPath, JSON.stringify({
+        sessionId,
+        cwd: resolvedCwd,
+        transcriptPath,
+        startedAt,
+        updatedAt: Date.now(),
+        kind: 'interactive',
+        entrypoint: 'cli',
+      }));
+    } catch (err) {
+      logOnce(err);
+    }
+  }
+
+  // Refresh only the session record's updatedAt so discovery keeps ranking
+  // this session as live across long-lived remote sessions.
+  function refresh() {
+    writeSessionRecord();
+  }
+
+  function appendAssistant(text) {
+    const value = typeof text === 'string' ? text : (text == null ? '' : String(text));
+    if (!value.trim()) return;
+    appendLine({
+      type: 'assistant',
+      sessionId,
+      message: { content: [{ type: 'text', text: value }] },
+    });
+  }
+
+  function appendToolUse(name, input) {
+    if (!name) return;
+    appendLine({
+      type: 'assistant',
+      sessionId,
+      message: { content: [{ type: 'tool_use', name, input: input || {} }] },
+    });
+  }
+
+  function appendToolResult(toolUseResult) {
+    if (!toolUseResult) return;
+    appendLine({
+      type: 'user',
+      sessionId,
+      message: { content: [{ type: 'tool_result' }] },
+      toolUseResult,
+    });
+  }
+
+  return {
+    transcriptPath,
+    sessionRecordPath,
+    writeSessionRecord,
+    refresh,
+    appendAssistant,
+    appendToolUse,
+    appendToolResult,
+  };
+}

package/src/runtime/shared/update-checker.mjs

@@ -0,0 +1,214 @@
+/**
+ * update-checker.mjs — npm registry version check + self-update for the
+ * globally-installed `mixdog` CLI package.
+ *
+ * checkLatestVersion({force}) hits the npm registry for the `latest`
+ * dist-tag, compares against the local package.json version, and caches
+ * the result on disk (TTL 24h) so repeated calls (e.g. on every TUI mount)
+ * don't hammer the registry. Network/parse failures are silent — this is a
+ * best-effort convenience check, never a boot-blocking dependency.
+ *
+ * runGlobalUpdate() shells out to `npm install -g mixdog@latest` in the
+ * background (windowsHide so no console flash on Windows) and resolves once
+ * the child exits, reporting the resolved version on success.
+ */
+
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spawn } from 'node:child_process';
+import { resolvePluginData } from './plugin-paths.mjs';
+
+const PACKAGE_NAME = 'mixdog';
+const REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+const FETCH_TIMEOUT_MS = 5_000;
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+const CACHE_FILE_NAME = 'update-check-cache.json';
+
+// Resolve the local package.json shipped alongside src/ (two levels up from
+// src/runtime/shared/).
+const _MODULE_DIR = dirname(fileURLToPath(import.meta.url));
+const _PACKAGE_JSON_PATH = join(_MODULE_DIR, '..', '..', '..', 'package.json');
+
+let _localVersionCache = null;
+export function localPackageVersion() {
+  if (_localVersionCache) return _localVersionCache;
+  try {
+    const raw = JSON.parse(readFileSync(_PACKAGE_JSON_PATH, 'utf8'));
+    _localVersionCache = String(raw?.version || '0.0.0');
+  } catch {
+    _localVersionCache = '0.0.0';
+  }
+  return _localVersionCache;
+}
+
+function cacheFilePath(dataDir) {
+  const dir = dataDir || resolvePluginData();
+  return join(dir, CACHE_FILE_NAME);
+}
+
+function readCache(dataDir) {
+  try {
+    const raw = JSON.parse(readFileSync(cacheFilePath(dataDir), 'utf8'));
+    if (!raw || typeof raw !== 'object') return null;
+    return raw;
+  } catch {
+    return null;
+  }
+}
+
+function writeCache(dataDir, payload) {
+  try {
+    const dir = dataDir || resolvePluginData();
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(cacheFilePath(dataDir), JSON.stringify(payload), 'utf8');
+  } catch {
+    // Best-effort — cache miss just means the next call re-fetches.
+  }
+}
+
+/** Parse a semver-ish string into { parts:[maj,min,patch], prerelease }. */
+function parseSemver(value) {
+  const text = String(value || '').trim().replace(/^v/i, '');
+  const [core, ...preParts] = text.split('-');
+  const parts = core.split('.').map((n) => {
+    const num = Number.parseInt(n, 10);
+    return Number.isFinite(num) ? num : 0;
+  });
+  while (parts.length < 3) parts.push(0);
+  return { parts, prerelease: preParts.join('-') };
+}
+
+/**
+ * Compare two semver strings. Returns positive if `a` > `b`, negative if
+ * `a` < `b`, 0 if equal. A version with a prerelease tag is considered
+ * lower than the same core version without one (standard semver rule).
+ */
+export function compareSemver(a, b) {
+  const pa = parseSemver(a);
+  const pb = parseSemver(b);
+  for (let i = 0; i < 3; i++) {
+    const diff = (pa.parts[i] || 0) - (pb.parts[i] || 0);
+    if (diff !== 0) return diff;
+  }
+  if (pa.prerelease && !pb.prerelease) return -1;
+  if (!pa.prerelease && pb.prerelease) return 1;
+  if (pa.prerelease !== pb.prerelease) return pa.prerelease < pb.prerelease ? -1 : 1;
+  return 0;
+}
+
+export function isNewerVersion(latest, current) {
+  if (!latest || !current) return false;
+  return compareSemver(latest, current) > 0;
+}
+
+async function fetchLatestFromRegistry() {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  try {
+    const res = await fetch(REGISTRY_URL, { signal: controller.signal });
+    if (!res.ok) return null;
+    const body = await res.json();
+    const version = body && typeof body === 'object' ? String(body.version || '').trim() : '';
+    return version || null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/**
+ * checkLatestVersion({force, dataDir}) — resolve the latest published
+ * version of the `mixdog` npm package.
+ *
+ * Returns:
+ *   { currentVersion, latestVersion, updateAvailable, lastCheckedAt, fromCache }
+ * `latestVersion` is null when the registry could not be reached and no
+ * usable cache exists — this call never throws.
+ */
+export async function checkLatestVersion({ force = false, dataDir } = {}) {
+  const currentVersion = localPackageVersion();
+  const cache = force ? null : readCache(dataDir);
+  const now = Date.now();
+  if (cache && typeof cache.lastCheckedAt === 'number' && now - cache.lastCheckedAt < CACHE_TTL_MS) {
+    return {
+      currentVersion,
+      latestVersion: cache.latestVersion || null,
+      updateAvailable: isNewerVersion(cache.latestVersion, currentVersion),
+      lastCheckedAt: cache.lastCheckedAt,
+      fromCache: true,
+    };
+  }
+  const latestVersion = await fetchLatestFromRegistry();
+  if (latestVersion) {
+    const payload = { latestVersion, lastCheckedAt: now };
+    writeCache(dataDir, payload);
+    return {
+      currentVersion,
+      latestVersion,
+      updateAvailable: isNewerVersion(latestVersion, currentVersion),
+      lastCheckedAt: now,
+      fromCache: false,
+    };
+  }
+  // Registry unreachable: fall back to a stale cache (if any) rather than
+  // reporting "no update info" every time the network hiccups.
+  if (cache && cache.latestVersion) {
+    return {
+      currentVersion,
+      latestVersion: cache.latestVersion,
+      updateAvailable: isNewerVersion(cache.latestVersion, currentVersion),
+      lastCheckedAt: cache.lastCheckedAt || now,
+      fromCache: true,
+    };
+  }
+  return {
+    currentVersion,
+    latestVersion: null,
+    updateAvailable: false,
+    lastCheckedAt: now,
+    fromCache: false,
+  };
+}
+
+/**
+ * runGlobalUpdate() — `npm install -g mixdog@latest` in a background child
+ * process (windowsHide so no console flash on Windows). Resolves once the
+ * child exits; never throws — failures come back as {ok:false, error}.
+ */
+export function runGlobalUpdate() {
+  return new Promise((resolvePromise) => {
+    let child;
+    try {
+      const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+      child = spawn(npmCmd, ['install', '-g', `${PACKAGE_NAME}@latest`], {
+        stdio: 'ignore',
+        windowsHide: true,
+        shell: process.platform === 'win32',
+      });
+    } catch (err) {
+      resolvePromise({ ok: false, error: err?.message || String(err) });
+      return;
+    }
+    child.once('error', (err) => {
+      resolvePromise({ ok: false, error: err?.message || String(err) });
+    });
+    // Detach from the event-loop keep-alive so a boot-time auto-update can
+    // never hold the TUI/node process open after the user quits; the exit
+    // listener still fires as long as the process is otherwise alive.
+    child.unref?.();
+    child.once('exit', async (code) => {
+      if (code === 0) {
+        // Best-effort: report whichever version the registry now reports as
+        // latest (the just-installed one), falling back to 'unknown'.
+        const version = await fetchLatestFromRegistry();
+        resolvePromise({ ok: true, version: version || 'unknown' });
+      } else {
+        resolvePromise({ ok: false, error: `npm install exited with code ${code}` });
+      }
+    });
+  });
+}
+
+export { PACKAGE_NAME as UPDATE_PACKAGE_NAME };