agent-mockingbird 0.0.1

package/scripts/check-ship.ts

@@ -0,0 +1,383 @@
+#!/usr/bin/env bun
+import { existsSync, readdirSync, statSync } from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { spawnSync } from "node:child_process";
+
+type CommandResult = {
+  status: number;
+  stdout: string;
+  stderr: string;
+  combined: string;
+};
+
+type SyncStatus = {
+  cleanroom: {
+    exists: boolean;
+    pristine: boolean | null;
+    matchesLock: boolean | null;
+    path: string;
+  };
+  vendor: {
+    exists: boolean;
+    state: "missing" | "clean" | "dirty" | "conflicted" | "invalid";
+    path: string;
+  };
+  patches: {
+    matchesBranch: boolean | null;
+  };
+};
+
+type Diagnostic = {
+  key: string;
+  line: string;
+};
+
+const repoRoot = path.resolve(import.meta.dir, "..");
+const cleanroomRoot = path.join(repoRoot, "cleanroom", "opencode");
+const vendorRoot = path.join(repoRoot, "vendor", "opencode");
+const trackedArtifactPaths = ["bin/agent-mockingbird"];
+
+main();
+
+function main() {
+  ensureOpencodeWorktree();
+  const initialStatus = readSyncStatus();
+  if (!initialStatus) {
+    fail("Unable to read OpenCode sync status after worktree setup.");
+  }
+  assertShipState(initialStatus);
+
+  runStep("Build CLI", ["bun", "run", "build:cli"]);
+  assertTrackedArtifactsSynced(["bin/agent-mockingbird"]);
+
+  runStep("Lint", ["bun", "run", "lint"]);
+  runStep("Typecheck", ["bun", "run", "typecheck"]);
+
+  runStep("OpenCode Patch Check", ["bun", "run", "opencode:sync", "--check"]);
+  runFilteredOpencodeTypecheck();
+
+  runStep("Build", ["bun", "run", "build"]);
+  assertDistAppBuilt();
+  assertTrackedArtifactsSynced(trackedArtifactPaths);
+
+  runStep("Build Standalone Runtime", ["bun", "run", "build:bin"]);
+  assertTrackedArtifactsSynced(["bin/agent-mockingbird"]);
+
+  console.log("\nShip check passed.");
+}
+
+function ensureOpencodeWorktree() {
+  const status = readSyncStatus({ allowFailure: true });
+  if (status && status.vendor.exists) {
+    return;
+  }
+
+  console.log("\n== Materialize OpenCode Worktree ==");
+  runCommand(["bun", "run", "opencode:sync", "--rebuild-only"]);
+}
+
+function assertShipState(status: SyncStatus) {
+  const problems: string[] = [];
+
+  if (!status.cleanroom.exists) {
+    problems.push("cleanroom/opencode is missing");
+  }
+  if (status.cleanroom.pristine !== true) {
+    problems.push("cleanroom/opencode is not pristine");
+  }
+  if (status.cleanroom.matchesLock !== true) {
+    problems.push("cleanroom/opencode does not match opencode.lock.json");
+  }
+  if (!status.vendor.exists) {
+    problems.push("vendor/opencode is missing");
+  }
+  if (status.vendor.state !== "clean") {
+    problems.push(`vendor/opencode is ${status.vendor.state}`);
+  }
+  if (status.patches.matchesBranch !== true) {
+    problems.push("patches/opencode does not match the vendor patch branch");
+  }
+
+  if (problems.length === 0) {
+    return;
+  }
+
+  const detail = problems.map((item) => `- ${item}`).join("\n");
+  fail(`OpenCode ship state is not clean:\n${detail}\n\nCommit/export vendor changes or rebuild the worktree before shipping.`);
+}
+
+function runFilteredOpencodeTypecheck() {
+  console.log("\n== OpenCode Dependency Install ==");
+  runCommand(["bun", "install", "--cwd", cleanroomRoot, "--frozen-lockfile"], {
+    quietLabel: "cleanroom/opencode",
+    env: bunInstallEnv(),
+  });
+  runCommand(["bun", "install", "--cwd", vendorRoot, "--frozen-lockfile"], {
+    quietLabel: "vendor/opencode",
+    env: bunInstallEnv(),
+  });
+
+  console.log("\n== OpenCode Full Typecheck ==");
+  const cleanroomResult = runCommand(
+    ["bun", "run", "--cwd", cleanroomRoot, "typecheck"],
+    { allowFailure: true, quietLabel: "cleanroom/opencode" },
+  );
+  const vendorResult = runCommand(
+    ["bun", "run", "--cwd", vendorRoot, "typecheck"],
+    { allowFailure: true, quietLabel: "vendor/opencode" },
+  );
+
+  if (cleanroomResult.status === 0 && vendorResult.status === 0) {
+    console.log("OpenCode cleanroom and vendor workspaces both typecheck cleanly.");
+    return;
+  }
+
+  if (cleanroomResult.status === 0 && vendorResult.status !== 0) {
+    fail(
+      "Patched OpenCode workspace typecheck failed while cleanroom passed.\n\nVendor output:\n" +
+        indentBlock(vendorResult.combined || "<no output>"),
+    );
+  }
+
+  const cleanroomDiagnostics = collectDiagnostics(cleanroomResult.combined, cleanroomRoot);
+  const vendorDiagnostics = collectDiagnostics(vendorResult.combined, vendorRoot);
+  const cleanroomKeys = new Set(cleanroomDiagnostics.map((item) => item.key));
+  const vendorOnlyDiagnostics = vendorDiagnostics.filter((item) => !cleanroomKeys.has(item.key));
+
+  if (vendorOnlyDiagnostics.length > 0) {
+    const detail = vendorOnlyDiagnostics.map((item) => `- ${item.line}`).join("\n");
+    fail(`Patched OpenCode introduced new typecheck diagnostics:\n${detail}`);
+  }
+
+  if (vendorDiagnostics.length === 0 && cleanroomDiagnostics.length === 0) {
+    const cleanroomComparable = normalizeComparableOutput(cleanroomResult.combined, cleanroomRoot);
+    const vendorComparable = normalizeComparableOutput(vendorResult.combined, vendorRoot);
+    if (cleanroomComparable !== vendorComparable) {
+      fail(
+        "OpenCode workspace typecheck failed in both cleanroom and vendor, but the failures do not normalize to the same output.\n\nVendor output:\n" +
+          indentBlock(vendorResult.combined || "<no output>"),
+      );
+    }
+  }
+
+  if (vendorResult.status !== 0) {
+    const baselineCount = vendorDiagnostics.length || countComparableLines(normalizeComparableOutput(vendorResult.combined, vendorRoot));
+    console.log(`Ignoring ${baselineCount} cleanroom-matching OpenCode typecheck issue(s).`);
+    if (vendorDiagnostics.length > 0) {
+      console.log("Ignored baseline diagnostics:");
+      for (const diagnostic of vendorDiagnostics) {
+        console.log(`- ${diagnostic.line}`);
+      }
+    }
+  }
+}
+
+function collectDiagnostics(output: string, workspaceRoot: string) {
+  const diagnostics = new Map<string, Diagnostic>();
+  const lines = stripAnsi(output).split(/\r?\n/);
+
+  for (const rawLine of lines) {
+    const line = rawLine.trimEnd();
+    const match = line.match(
+      /^(?<task>.+?:typecheck:\s+)?(?<file>.+?)\((?<line>\d+),(?<column>\d+)\): error TS(?<code>\d+): (?<message>.+)$/,
+    );
+    if (!match?.groups) {
+      continue;
+    }
+
+    const file = normalizePath(match.groups.file, workspaceRoot);
+    const row = match.groups.line;
+    const column = match.groups.column;
+    const code = `TS${match.groups.code}`;
+    const message = match.groups.message.trim();
+    const key = [file, row, column, code, message].join("|");
+    diagnostics.set(key, { key, line: `${file}(${row},${column}): error ${code}: ${message}` });
+  }
+
+  return [...diagnostics.values()];
+}
+
+function normalizeComparableOutput(output: string, workspaceRoot: string) {
+  const lines = stripAnsi(output)
+    .split(/\r?\n/)
+    .map((line) => line.trimEnd())
+    .filter(Boolean)
+    .filter((line) => !isNoiseLine(line))
+    .map((line) => normalizeRoot(line, workspaceRoot));
+  return lines.join("\n");
+}
+
+function countComparableLines(output: string) {
+  if (!output) {
+    return 0;
+  }
+  return output.split("\n").filter(Boolean).length;
+}
+
+function isNoiseLine(line: string) {
+  return (
+    line === "$ bun turbo typecheck" ||
+    line.startsWith("• turbo ") ||
+    line.startsWith("• Packages in scope:") ||
+    line.startsWith("• Running typecheck in ") ||
+    line.startsWith("• Remote caching ") ||
+    line.startsWith("Tasks:") ||
+    line.startsWith("Cached:") ||
+    line.startsWith("Time:")
+  );
+}
+
+function normalizePath(filePath: string, workspaceRoot: string) {
+  const normalized = filePath.replaceAll("\\", "/");
+  if (path.isAbsolute(normalized)) {
+    return normalizeRoot(normalized, workspaceRoot);
+  }
+  return normalized.replace(/^\.\//, "");
+}
+
+function normalizeRoot(value: string, workspaceRoot: string) {
+  const normalizedRoot = workspaceRoot.replaceAll("\\", "/");
+  return value.replaceAll(normalizedRoot, "<workspace>").replaceAll(repoRoot.replaceAll("\\", "/"), "<repo>");
+}
+
+function assertDistAppBuilt() {
+  const indexPath = path.join(repoRoot, "dist", "app", "index.html");
+  const assetsPath = path.join(repoRoot, "dist", "app", "assets");
+
+  if (!existsSync(indexPath)) {
+    fail("Missing dist/app/index.html after build.");
+  }
+  if (!existsSync(assetsPath) || !directoryHasFiles(assetsPath)) {
+    fail("Missing built OpenCode app assets in dist/app/assets after build.");
+  }
+}
+
+function directoryHasFiles(targetPath: string): boolean {
+  for (const entry of readdirSync(targetPath)) {
+    const entryPath = path.join(targetPath, entry);
+    const stats = statSync(entryPath);
+    if (stats.isFile()) {
+      return true;
+    }
+    if (stats.isDirectory() && directoryHasFiles(entryPath)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function assertTrackedArtifactsSynced(pathsToCheck: string[]) {
+  const result = runCommand(["git", "diff", "--name-only", "--", ...pathsToCheck], { allowFailure: true, printCommand: false });
+  const changed = result.stdout
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+  if (changed.length === 0) {
+    return;
+  }
+
+  const detail = changed.map((item) => `- ${item}`).join("\n");
+  fail(`Generated artifacts are out of sync:\n${detail}\n\nRebuild and commit the generated outputs before shipping.`);
+}
+
+function readSyncStatus(options?: { allowFailure?: boolean }): SyncStatus | null {
+  const result = runCommand(
+    ["bun", "run", "opencode:sync", "--status", "--json"],
+    { allowFailure: options?.allowFailure ?? false, printCommand: false, suppressOutput: true },
+  );
+  if (result.status !== 0) {
+    return null;
+  }
+
+  try {
+    return JSON.parse(result.stdout) as SyncStatus;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    fail(`Failed to parse opencode sync status JSON: ${message}`);
+  }
+}
+
+function runStep(label: string, command: string[]) {
+  console.log(`\n== ${label} ==`);
+  runCommand(command);
+}
+
+function runCommand(
+  command: string[],
+  options: {
+    allowFailure?: boolean;
+    cwd?: string;
+    printCommand?: boolean;
+    quietLabel?: string;
+    suppressOutput?: boolean;
+    env?: NodeJS.ProcessEnv;
+  } = {},
+): CommandResult {
+  const cwd = options.cwd ?? repoRoot;
+  if (options.printCommand !== false) {
+    console.log(`$ ${command.join(" ")}`);
+  }
+
+  const result = spawnSync(command[0], command.slice(1), {
+    cwd,
+    encoding: "utf8",
+    env: options.env ?? process.env,
+  });
+
+  const stdout = result.stdout || "";
+  const stderr = result.stderr || "";
+  const combined = [stdout, stderr].filter(Boolean).join(stdout && stderr ? "\n" : "");
+
+  if (options.suppressOutput) {
+    // Intentionally silent.
+  } else if (options.quietLabel) {
+    const summary = result.status === 0 ? "passed" : `failed (${result.status ?? "unknown"})`;
+    console.log(`${options.quietLabel}: ${summary}`);
+  } else {
+    if (stdout) {
+      process.stdout.write(stdout);
+    }
+    if (stderr) {
+      process.stderr.write(stderr);
+    }
+  }
+
+  if ((result.status ?? 0) !== 0 && !options.allowFailure) {
+    fail(
+      `Command failed: ${command.join(" ")}\n\n${combined ? indentBlock(combined) : "  <no output>"}`,
+      result.status ?? 1,
+    );
+  }
+
+  return {
+    status: result.status ?? 0,
+    stdout,
+    stderr,
+    combined,
+  };
+}
+
+function indentBlock(value: string) {
+  return value
+    .split(/\r?\n/)
+    .map((line) => `  ${line}`)
+    .join("\n");
+}
+
+function stripAnsi(value: string) {
+  return value.replace(/\u001b\[[0-9;?]*[ -/]*[@-~]/g, "");
+}
+
+function bunInstallEnv() {
+  return {
+    ...process.env,
+    GITHUB_SERVER_URL: "https://github.com",
+    GITHUB_API_URL: "https://api.github.com",
+  };
+}
+
+function fail(message: string, code = 1): never {
+  console.error(`\n${message}`);
+  process.exit(code);
+}

package/scripts/dev-opencode.sh

@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+WORKSPACE_DIR="${OPENCODE_WORKSPACE_DIR:-${ROOT_DIR}/apps/server/data/workspace}"
+OPENCODE_HOST="${OPENCODE_HOST:-127.0.0.1}"
+OPENCODE_PORT="${OPENCODE_PORT:-4096}"
+
+mkdir -p "${WORKSPACE_DIR}"
+cd "${WORKSPACE_DIR}"
+
+exec bun run "${ROOT_DIR}/vendor/opencode/packages/opencode/src/index.ts" \
+  serve \
+  --hostname "${OPENCODE_HOST}" \
+  --port "${OPENCODE_PORT}" \
+  --print-logs \
+  --log-level INFO

package/scripts/dev-stack-opencode.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+OPENCODE_HOST="${OPENCODE_HOST:-127.0.0.1}"
+OPENCODE_PORT="${OPENCODE_PORT:-4096}"
+OPENCODE_HEALTH_URL="http://${OPENCODE_HOST}:${OPENCODE_PORT}/global/health"
+STARTUP_TIMEOUT_SECONDS="${OPENCODE_STARTUP_TIMEOUT_SECONDS:-30}"
+
+cd "${ROOT_DIR}"
+
+bun run build:app
+concurrently -k -n opencode,server -c cyan,green \
+  "bun run dev:opencode" \
+  "bash -lc 'set -euo pipefail; echo \"[stack] waiting for OpenCode at ${OPENCODE_HEALTH_URL}\"; deadline=\$((SECONDS + ${STARTUP_TIMEOUT_SECONDS})); until curl -fsS \"${OPENCODE_HEALTH_URL}\" >/dev/null 2>&1; do if (( SECONDS >= deadline )); then echo \"[stack] timed out waiting for OpenCode health after ${STARTUP_TIMEOUT_SECONDS}s\"; exit 1; fi; sleep 0.25; done; echo \"[stack] OpenCode is healthy, starting Agent Mockingbird\"; exec bun run dev:server'"

package/scripts/dev-stack.sh

@@ -0,0 +1,61 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+WAFFLEBOT_PORT="${PORT:-${AGENT_MOCKINGBIRD_PORT:-3001}}"
+DEV_WORKSPACE_DIR="${AGENT_MOCKINGBIRD_MEMORY_WORKSPACE_DIR:-${ROOT_DIR}/data/workspace}"
+DEV_CONFIG_PATH="${AGENT_MOCKINGBIRD_CONFIG_PATH:-${ROOT_DIR}/data/agent-mockingbird.dev-stack.config.json}"
+DEV_OPENCODE_CONFIG_DIR="${AGENT_MOCKINGBIRD_OPENCODE_CONFIG_DIR:-${ROOT_DIR}/data/opencode-config/dev-stack}"
+DEV_WORKSPACE_ASSETS_STATE_PATH="${AGENT_MOCKINGBIRD_RUNTIME_WORKSPACE_ASSETS_STATE_PATH:-${ROOT_DIR}/data/runtime-assets-workspace.dev-stack.json}"
+DEV_OPENCODE_ASSETS_STATE_PATH="${AGENT_MOCKINGBIRD_RUNTIME_OPENCODE_ASSETS_STATE_PATH:-${ROOT_DIR}/data/runtime-assets-opencode-config.dev-stack.json}"
+
+if ! command -v bun >/dev/null 2>&1; then
+  echo "bun is required but not found in PATH."
+  exit 1
+fi
+
+echo "[stack] syncing runtime assets into ${DEV_WORKSPACE_DIR}"
+(
+  cd "${ROOT_DIR}"
+  bun scripts/runtime-assets-sync.mjs \
+    --source "${ROOT_DIR}/runtime-assets/workspace" \
+    --target "${DEV_WORKSPACE_DIR}" \
+    --state "${DEV_WORKSPACE_ASSETS_STATE_PATH}" \
+    --mode install \
+    --non-interactive \
+    --quiet
+)
+
+echo "[stack] syncing OpenCode config assets into ${DEV_OPENCODE_CONFIG_DIR}"
+(
+  cd "${ROOT_DIR}"
+  bun scripts/runtime-assets-sync.mjs \
+    --source "${ROOT_DIR}/runtime-assets/opencode-config" \
+    --target "${DEV_OPENCODE_CONFIG_DIR}" \
+    --state "${DEV_OPENCODE_ASSETS_STATE_PATH}" \
+    --mode install \
+    --non-interactive \
+    --quiet
+)
+
+if [[ -f "${DEV_OPENCODE_CONFIG_DIR}/package.json" ]]; then
+  echo "[stack] installing managed OpenCode config dependencies"
+  (
+    cd "${DEV_OPENCODE_CONFIG_DIR}"
+    bun install --frozen-lockfile >/dev/null
+  )
+fi
+
+echo "[stack] starting agent-mockingbird on http://127.0.0.1:${WAFFLEBOT_PORT}"
+echo "[stack] workspace: ${DEV_WORKSPACE_DIR}"
+echo "[stack] opencode-config: ${DEV_OPENCODE_CONFIG_DIR}"
+echo "[stack] config: ${DEV_CONFIG_PATH}"
+
+cd "${ROOT_DIR}"
+export PORT="${WAFFLEBOT_PORT}"
+export AGENT_MOCKINGBIRD_PORT="${WAFFLEBOT_PORT}"
+export AGENT_MOCKINGBIRD_MEMORY_WORKSPACE_DIR="${DEV_WORKSPACE_DIR}"
+export AGENT_MOCKINGBIRD_CONFIG_PATH="${DEV_CONFIG_PATH}"
+export OPENCODE_CONFIG_DIR="${DEV_OPENCODE_CONFIG_DIR}"
+export OPENCODE_DISABLE_PROJECT_CONFIG="1"
+exec bun --hot apps/server/src/index.ts

package/scripts/install-systemd.sh

@@ -0,0 +1,87 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+if [[ "${EUID}" -ne 0 ]]; then
+  echo "Run as root (sudo)."
+  exit 1
+fi
+
+APP_USER="${AGENT_MOCKINGBIRD_USER:-agent-mockingbird}"
+APP_GROUP="${AGENT_MOCKINGBIRD_GROUP:-${APP_USER}}"
+APP_DIR="${AGENT_MOCKINGBIRD_APP_DIR:-/srv/agent-mockingbird/app}"
+DATA_DIR="${AGENT_MOCKINGBIRD_DATA_DIR:-/var/lib/agent-mockingbird}"
+OPENCODE_CONFIG_DIR="${AGENT_MOCKINGBIRD_OPENCODE_CONFIG_DIR:-${DATA_DIR}/opencode-config/systemd}"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+UNIT_DIR="/etc/systemd/system"
+TMP_DIR="$(mktemp -d)"
+
+cleanup() {
+  rm -rf "${TMP_DIR}"
+}
+trap cleanup EXIT
+
+require_cmd() {
+  local cmd="$1"
+  if ! command -v "${cmd}" >/dev/null 2>&1; then
+    echo "${cmd} is required but not installed."
+    exit 1
+  fi
+}
+
+require_cmd bun
+require_cmd opencode
+require_cmd systemctl
+require_cmd tar
+
+if ! getent group "${APP_GROUP}" >/dev/null 2>&1; then
+  groupadd --system "${APP_GROUP}"
+fi
+
+if ! id -u "${APP_USER}" >/dev/null 2>&1; then
+  useradd --system --home-dir "${APP_DIR}" --gid "${APP_GROUP}" --shell /usr/sbin/nologin "${APP_USER}"
+fi
+
+mkdir -p "${APP_DIR}" "${DATA_DIR}"
+
+# Copy extracted release content into final app directory.
+tar -C "${SCRIPT_DIR}" -cf - . | tar -C "${APP_DIR}" -xf -
+
+chown -R "${APP_USER}:${APP_GROUP}" "${APP_DIR}" "${DATA_DIR}"
+
+su -s /bin/bash -c "cd \"${APP_DIR}\" && bun install --frozen-lockfile" "${APP_USER}"
+su -s /bin/bash -c "cd \"${APP_DIR}\" && bun scripts/runtime-assets-sync.mjs --source \"${APP_DIR}/runtime-assets/workspace\" --target \"${APP_DIR}\" --state \"${DATA_DIR}/runtime-assets-workspace-state.json\" --mode install --non-interactive" "${APP_USER}"
+su -s /bin/bash -c "cd \"${APP_DIR}\" && bun scripts/runtime-assets-sync.mjs --source \"${APP_DIR}/runtime-assets/opencode-config\" --target \"${OPENCODE_CONFIG_DIR}\" --state \"${DATA_DIR}/runtime-assets-opencode-config-state.json\" --mode install --non-interactive" "${APP_USER}"
+if [[ -f "${OPENCODE_CONFIG_DIR}/package.json" ]]; then
+  su -s /bin/bash -c "cd \"${OPENCODE_CONFIG_DIR}\" && bun install --frozen-lockfile" "${APP_USER}"
+fi
+
+render_unit() {
+  local src="$1"
+  local dst="$2"
+
+  sed \
+    -e "s|^User=.*$|User=${APP_USER}|" \
+    -e "s|^Group=.*$|Group=${APP_GROUP}|" \
+    -e "s|^WorkingDirectory=.*$|WorkingDirectory=${APP_DIR}|" \
+    -e "s|__AGENT_MOCKINGBIRD_OPENCODE_CONFIG_DIR__|${OPENCODE_CONFIG_DIR}|g" \
+    -e "s|/srv/agent-mockingbird/app|${APP_DIR}|g" \
+    -e "s|/var/lib/agent-mockingbird|${DATA_DIR}|g" \
+    "${src}" > "${dst}"
+}
+
+render_unit "${APP_DIR}/deploy/systemd/opencode.service" "${TMP_DIR}/opencode.service"
+render_unit "${APP_DIR}/deploy/systemd/agent-mockingbird.service" "${TMP_DIR}/agent-mockingbird.service"
+
+install -m 0644 "${TMP_DIR}/opencode.service" "${UNIT_DIR}/opencode.service"
+install -m 0644 "${TMP_DIR}/agent-mockingbird.service" "${UNIT_DIR}/agent-mockingbird.service"
+
+systemctl daemon-reload
+systemctl enable --now opencode.service agent-mockingbird.service
+
+echo "Installed agent-mockingbird with systemd services:"
+echo "  opencode.service"
+echo "  agent-mockingbird.service"
+echo
+echo "Health checks:"
+echo "  curl -sS http://127.0.0.1:3001/api/health"
+echo "  systemctl status agent-mockingbird.service --no-pager"

package/scripts/memory-e2e.sh

@@ -0,0 +1,76 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "${ROOT_DIR}"
+
+if [[ -f ".env" ]]; then
+  while IFS= read -r line || [[ -n "${line}" ]]; do
+    if [[ "${line}" =~ ^[[:space:]]*# ]] || [[ "${line}" =~ ^[[:space:]]*$ ]]; then
+      continue
+    fi
+    if [[ "${line}" =~ ^[[:space:]]*([A-Za-z_][A-Za-z0-9_]*)=(.*)$ ]]; then
+      key="${BASH_REMATCH[1]}"
+      value="${BASH_REMATCH[2]}"
+      if [[ -z "${!key+x}" ]]; then
+        export "${key}=${value}"
+      fi
+    fi
+  done < ".env"
+fi
+
+if ! command -v bun >/dev/null 2>&1; then
+  echo "[memory:e2e] bun is required but not found in PATH."
+  exit 1
+fi
+
+if ! command -v curl >/dev/null 2>&1; then
+  echo "[memory:e2e] curl is required but not found in PATH."
+  exit 1
+fi
+
+MEMORY_ENABLED="${AGENT_MOCKINGBIRD_MEMORY_ENABLED:-true}"
+EMBED_PROVIDER="${AGENT_MOCKINGBIRD_MEMORY_EMBED_PROVIDER:-ollama}"
+OLLAMA_BASE_URL="${AGENT_MOCKINGBIRD_MEMORY_OLLAMA_BASE_URL:-http://127.0.0.1:11434}"
+EMBED_MODEL="${AGENT_MOCKINGBIRD_MEMORY_EMBED_MODEL:-qwen3-embedding:4b}"
+
+echo "[memory:e2e] starting"
+echo "[memory:e2e] provider=${EMBED_PROVIDER} model=${EMBED_MODEL}"
+
+if [[ "${MEMORY_ENABLED}" != "true" ]]; then
+  echo "[memory:e2e] AGENT_MOCKINGBIRD_MEMORY_ENABLED must be true."
+  exit 1
+fi
+
+if [[ "${EMBED_PROVIDER}" == "ollama" ]]; then
+  echo "[memory:e2e] checking ollama at ${OLLAMA_BASE_URL}"
+  if ! curl -fsS "${OLLAMA_BASE_URL}/api/tags" >/dev/null; then
+    echo "[memory:e2e] failed to reach Ollama tags endpoint."
+    echo "[memory:e2e] set AGENT_MOCKINGBIRD_MEMORY_OLLAMA_BASE_URL or run with AGENT_MOCKINGBIRD_MEMORY_EMBED_PROVIDER=none."
+    exit 1
+  fi
+fi
+
+echo "[memory:e2e] memory status"
+bun run src/backend/memory/cli.ts status
+
+echo "[memory:e2e] forcing reindex"
+bun run src/backend/memory/cli.ts reindex
+
+MARKER="memory-e2e-$(date +%s)-$RANDOM"
+CONTENT="E2E marker ${MARKER} created at $(date -u +%Y-%m-%dT%H:%M:%SZ)"
+
+echo "[memory:e2e] writing marker"
+bun run src/backend/memory/cli.ts remember fact "${CONTENT}" >/tmp/agent-mockingbird-memory-e2e-remember.json
+
+echo "[memory:e2e] searching marker"
+SEARCH_OUTPUT="$(bun run src/backend/memory/cli.ts search "${MARKER}")"
+printf '%s\n' "${SEARCH_OUTPUT}" >/tmp/agent-mockingbird-memory-e2e-search.json
+
+if [[ "${SEARCH_OUTPUT}" != *"${MARKER}"* ]]; then
+  echo "[memory:e2e] marker was not found in retrieval output."
+  echo "[memory:e2e] wrote debug output to /tmp/agent-mockingbird-memory-e2e-search.json"
+  exit 1
+fi
+
+echo "[memory:e2e] PASS marker=${MARKER}"