@cairnkeep/cli 2.0.0 → 2.2.0

package/scripts/test-container-runner.sh

@@ -0,0 +1,83 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT=$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)
+tmp=$(mktemp -d)
+trap 'rm -rf "$tmp"' EXIT
+
+capture=$tmp/args
+engine=$tmp/podman
+repo=$tmp/repository
+token=$tmp/token
+env_file=$tmp/container.env
+mkdir -p "$repo"
+printf 'token\n' > "$token"
+printf 'CAIRN_MEMORY_EMBEDDING_MODEL=example\n' > "$env_file"
+chmod 600 "$token"
+
+cat > "$engine" <<'EOF'
+#!/bin/sh
+printf '%s\n' "$@" > "$CAIRN_CONTAINER_CAPTURE"
+EOF
+chmod 755 "$engine"
+
+run_launcher() {
+  CAIRN_CONTAINER_CAPTURE=$capture CONTAINER_ENGINE=$engine \
+    "$ROOT/scripts/cairn-container" "$@"
+}
+
+has_arg() {
+  grep -Fqx -- "$1" "$capture" || {
+    echo "FAIL: missing container argument: $1" >&2
+    exit 1
+  }
+}
+
+lacks_arg() {
+  if grep -Fqx -- "$1" "$capture"; then
+    echo "FAIL: unexpected container argument: $1" >&2
+    exit 1
+  fi
+}
+
+run_launcher stdio --image example/server:1 --volume example-data
+has_arg --userns=keep-id:uid=10001,gid=10001
+has_arg --read-only
+has_arg --cap-drop=all
+has_arg example-data:/data:Z,U
+has_arg example/server:1
+has_arg stdio
+
+run_launcher http --image example/server:1 --token-file "$token" --port 8123 \
+  --allowed-hosts memory.example.com --env-file "$env_file"
+has_arg --detach
+has_arg 127.0.0.1:8123:7801
+has_arg "$token:/run/secrets/http-token:ro,Z"
+has_arg CAIRN_MEMORY_HTTP_ALLOWED_HOSTS=memory.example.com
+has_arg CAIRN_MEMORY_HTTP_TOKEN_FILE=/run/secrets/http-token
+has_arg "$env_file"
+
+chmod 644 "$token"
+if run_launcher http --token-file "$token" >"$tmp/out" 2>"$tmp/err"; then
+  echo "FAIL: permissive token file was accepted" >&2
+  exit 1
+fi
+grep -Fq "mode 400 or 600" "$tmp/err"
+chmod 600 "$token"
+
+run_launcher workspace --repo "$repo" --image example/workspace:1 \
+  --workspace-volume example-workspace -- echo sandbox
+has_arg "$repo:/source:ro,Z"
+has_arg example-workspace:/workspace:Z,U
+has_arg CAIRN_WORKSPACE_MODE=sandbox
+lacks_arg "$repo:/workspace:rw,Z"
+has_arg echo
+has_arg sandbox
+
+run_launcher workspace --repo "$repo" --mode shared --image example/workspace:1
+has_arg "$repo:/workspace:rw,Z"
+has_arg CAIRN_WORKSPACE_MODE=shared
+lacks_arg "$repo:/source:ro,Z"
+has_arg bash
+
+echo "PASS: container launcher security and workspace contracts"

package/scripts/test-container.sh

@@ -0,0 +1,183 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+if [[ "${CAIRN_TEST_CONTAINERS:-0}" != 1 ]]; then
+  echo "SKIP: container integration (set CAIRN_TEST_CONTAINERS=1 to run)"
+  exit 0
+fi
+
+ROOT=$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)
+ENGINE=${CONTAINER_ENGINE:-}
+if [[ -z "$ENGINE" ]]; then
+  if command -v podman >/dev/null 2>&1; then ENGINE=podman
+  elif command -v docker >/dev/null 2>&1; then ENGINE=docker
+  else echo "FAIL: Podman or Docker is required" >&2; exit 1
+  fi
+fi
+command -v "$ENGINE" >/dev/null 2>&1 || { echo "FAIL: container engine not found: $ENGINE" >&2; exit 1; }
+
+suffix=$$
+server_image="localhost/cairnkeep-test-server:$suffix"
+workspace_image="localhost/cairnkeep-test-workspace:$suffix"
+volume="cairnkeep-test-data-$suffix"
+sandbox_volume="cairnkeep-test-workspace-$suffix"
+name="cairnkeep-test-$suffix"
+tmp=$(mktemp -d)
+
+cleanup() {
+  "$ENGINE" rm -f "$name" >/dev/null 2>&1 || true
+  "$ENGINE" volume rm -f "$volume" "$sandbox_volume" >/dev/null 2>&1 || true
+  "$ENGINE" image rm -f "$server_image" "$workspace_image" >/dev/null 2>&1 || true
+  rm -rf "$tmp"
+}
+trap cleanup EXIT
+
+cd "$ROOT"
+"$ENGINE" build --target server -t "$server_image" -f Containerfile .
+"$ENGINE" build --target workspace -t "$workspace_image" -f Containerfile .
+
+image_user=$("$ENGINE" image inspect --format '{{.Config.User}}' "$server_image")
+[[ "$image_user" == "10001:10001" ]] || {
+  echo "FAIL: server image must run as 10001:10001, got $image_user" >&2
+  exit 1
+}
+
+"$ENGINE" volume create "$volume" >/dev/null
+node scripts/probe-memory-server.mjs --command \
+  "$ENGINE" run --rm -i --volume "$volume:/data" "$server_image" stdio
+
+if "$ENGINE" run --rm "$server_image" http >/dev/null 2>&1; then
+  echo "FAIL: HTTP mode started without a token" >&2
+  exit 1
+fi
+
+token=container-smoke-token
+printf '%s' "$token" > "$tmp/http-token"
+# Docker bind mounts preserve the host UID; world-read is acceptable for this
+# non-secret fixture. The real Podman launcher requires mode 400 or 600.
+chmod 644 "$tmp/http-token"
+port=$(node -e 'const s=require("net").createServer();s.listen(0,"127.0.0.1",()=>{console.log(s.address().port);s.close()})')
+
+start_http() {
+  "$ENGINE" run --detach --name "$name" \
+    --read-only --cap-drop=all --security-opt=no-new-privileges \
+    --tmpfs /tmp:rw,noexec,nosuid,size=64m,mode=1777 \
+    --publish "127.0.0.1:${port}:7801" \
+    --volume "$volume:/data" \
+    --volume "$tmp/http-token:/run/secrets/http-token:ro" \
+    --env MCP_HTTP_HOST=0.0.0.0 \
+    --env MCP_HTTP_PORT=7801 \
+    --env "CAIRN_MEMORY_HTTP_ALLOWED_HOSTS=127.0.0.1:${port}" \
+    --env CAIRN_MEMORY_HTTP_TOKEN_FILE=/run/secrets/http-token \
+    "$server_image" http >/dev/null
+
+  for _ in $(seq 1 50); do
+    if node scripts/probe-container-memory.mjs read "http://127.0.0.1:${port}/mcp" "$token" \
+      >"$tmp/read.out" 2>"$tmp/read.err"; then
+      return 0
+    fi
+    if ! "$ENGINE" inspect "$name" >/dev/null 2>&1; then break; fi
+    sleep 0.2
+  done
+  return 1
+}
+
+# First boot: wait for MCP, then write the canary.
+"$ENGINE" run --detach --name "$name" \
+  --read-only --cap-drop=all --security-opt=no-new-privileges \
+  --tmpfs /tmp:rw,noexec,nosuid,size=64m,mode=1777 \
+  --publish "127.0.0.1:${port}:7801" \
+  --volume "$volume:/data" \
+  --volume "$tmp/http-token:/run/secrets/http-token:ro" \
+  --env MCP_HTTP_HOST=0.0.0.0 \
+  --env MCP_HTTP_PORT=7801 \
+  --env "CAIRN_MEMORY_HTTP_ALLOWED_HOSTS=127.0.0.1:${port}" \
+  --env CAIRN_MEMORY_HTTP_TOKEN_FILE=/run/secrets/http-token \
+  "$server_image" http >/dev/null
+written=0
+for _ in $(seq 1 50); do
+  if node scripts/probe-container-memory.mjs write "http://127.0.0.1:${port}/mcp" "$token" \
+    >"$tmp/write.out" 2>"$tmp/write.err"; then
+    written=1
+    break
+  fi
+  sleep 0.2
+done
+[[ "$written" == 1 ]] || {
+  cat "$tmp/write.err" >&2
+  echo "FAIL: container HTTP server did not become ready" >&2
+  exit 1
+}
+cat "$tmp/write.out"
+"$ENGINE" exec "$name" node /usr/local/lib/cairnkeep/container-healthcheck.mjs
+"$ENGINE" rm -f "$name" >/dev/null
+
+# Replacement boot with the same volume must recover the canary.
+start_http || {
+  cat "$tmp/read.err" >&2
+  echo "FAIL: persisted memory was not readable after replacement" >&2
+  exit 1
+}
+cat "$tmp/read.out"
+"$ENGINE" rm -f "$name" >/dev/null
+
+mkdir -p "$tmp/repo"
+printf 'source\n' > "$tmp/repo/source.txt"
+
+# Shared mode deliberately writes through to the selected host repository.
+if [[ "$ENGINE" == podman ]]; then
+  "$ENGINE" run --rm --userns=keep-id:uid=10001,gid=10001 \
+    --volume "$tmp/repo:/workspace:Z" \
+    --env CAIRN_WORKSPACE_MODE=shared \
+    "$workspace_image" sh -c 'printf shared > shared.txt'
+else
+  chmod 755 "$tmp"
+  chmod 777 "$tmp/repo"
+  chmod 666 "$tmp/repo/source.txt"
+  "$ENGINE" run --rm \
+    --volume "$tmp/repo:/workspace" \
+    --env CAIRN_WORKSPACE_MODE=shared \
+    "$workspace_image" sh -c 'printf shared > shared.txt'
+fi
+[[ $(cat "$tmp/repo/shared.txt") == shared ]] || {
+  echo "FAIL: shared workspace did not write through" >&2
+  exit 1
+}
+
+# Prepare a writable named volume for the image's unprivileged runtime user.
+"$ENGINE" volume create "$sandbox_volume" >/dev/null
+if [[ "$ENGINE" == podman ]]; then
+  "$ENGINE" run --rm --userns=keep-id:uid=10001,gid=10001 \
+    --volume "$tmp/repo:/source:ro,Z" \
+    --volume "$sandbox_volume:/workspace:Z,U" \
+    --env CAIRN_WORKSPACE_MODE=sandbox \
+    "$workspace_image" sh -c 'printf sandbox > sandbox.txt'
+else
+  "$ENGINE" run --rm --user root --entrypoint sh \
+    --volume "$sandbox_volume:/workspace" "$workspace_image" \
+    -c 'chown 10001:10001 /workspace'
+  "$ENGINE" run --rm \
+    --volume "$tmp/repo:/source:ro" \
+    --volume "$sandbox_volume:/workspace" \
+    --env CAIRN_WORKSPACE_MODE=sandbox \
+    "$workspace_image" sh -c 'printf sandbox > sandbox.txt'
+fi
+[[ ! -e "$tmp/repo/sandbox.txt" ]] || {
+  echo "FAIL: sandbox mode modified the host repository" >&2
+  exit 1
+}
+if [[ "$ENGINE" == podman ]]; then
+  "$ENGINE" run --rm --userns=keep-id:uid=10001,gid=10001 \
+    --volume "$tmp/repo:/source:ro,Z" \
+    --volume "$sandbox_volume:/workspace:Z,U" \
+    --env CAIRN_WORKSPACE_MODE=sandbox \
+    "$workspace_image" sh -c 'test "$(cat sandbox.txt)" = sandbox'
+else
+  "$ENGINE" run --rm \
+    --volume "$tmp/repo:/source:ro" \
+    --volume "$sandbox_volume:/workspace" \
+    --env CAIRN_WORKSPACE_MODE=sandbox \
+    "$workspace_image" sh -c 'test "$(cat sandbox.txt)" = sandbox'
+fi
+
+echo "PASS: container stdio, guarded HTTP, persistence, shared, and sandbox modes"

package/scripts/test-doctor.sh

@@ -5,7 +5,12 @@ set -uo pipefail
 
 ROOT=$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)
 tmp=$(mktemp -d)
-trap 'rm -rf "$tmp"' EXIT
+server_pid=""
+cleanup() {
+  [[ -n "$server_pid" ]] && kill "$server_pid" 2>/dev/null || true
+  rm -rf "$tmp"
+}
+trap cleanup EXIT
 fail() { echo "FAIL: $1" >&2; exit 1; }
 
 doctor="$ROOT/scripts/doctor.sh"
@@ -46,4 +51,59 @@ else
   echo "  (curl absent — skipped the unreachable-endpoint case)"
 fi
 
-echo "PASS: cairn doctor (skip unconfigured, fail configured-unreachable)"
+# 4. The embedding check performs a real authenticated model request.
+if command -v curl >/dev/null 2>&1; then
+  cat > "$tmp/embedding-server.mjs" <<'EOF'
+import { createServer } from "node:http";
+import { writeFileSync } from "node:fs";
+
+const server = createServer((request, response) => {
+  const chunks = [];
+  request.on("data", (chunk) => chunks.push(chunk));
+  request.on("end", () => {
+    let body = {};
+    try { body = JSON.parse(Buffer.concat(chunks).toString("utf8")); } catch {}
+    const valid = request.url === "/v1/embeddings"
+      && request.headers.authorization === "Bearer test-key"
+      && body.model === "test-embedding";
+    response.writeHead(valid ? 200 : 404, { "Content-Type": "application/json" });
+    response.end(JSON.stringify(valid
+      ? { data: [{ index: 0, embedding: [1, 0] }] }
+      : { error: "invalid request" }));
+  });
+});
+server.listen(0, "127.0.0.1", () => {
+  writeFileSync(process.argv[2], String(server.address().port));
+});
+EOF
+  node "$tmp/embedding-server.mjs" "$tmp/embedding-port" &
+  server_pid=$!
+  for _ in $(seq 1 50); do [[ -s "$tmp/embedding-port" ]] && break; sleep 0.1; done
+  [[ -s "$tmp/embedding-port" ]] || fail "embedding test server did not start"
+  port=$(cat "$tmp/embedding-port")
+
+  proj3="$tmp/embedding-ok"; mkdir -p "$proj3/.ai"
+  cat > "$proj3/.ai/.env" <<EOF
+CAIRN_MEMORY_EMBEDDING_URL=http://127.0.0.1:$port/v1
+CAIRN_MEMORY_EMBEDDING_MODEL=test-embedding
+CAIRN_LLM_API_KEY=test-key
+EOF
+  ( cd "$proj3" && "$doctor" ) >"$tmp/out3" 2>&1 ||
+    fail "doctor rejected a working embedding endpoint:\n$(cat "$tmp/out3")"
+  grep -q "\[PASS\] embedding endpoint accepted model test-embedding" "$tmp/out3" ||
+    fail "expected a functional embedding PASS line"
+
+  proj4="$tmp/embedding-wrong-model"; mkdir -p "$proj4/.ai"
+  cat > "$proj4/.ai/.env" <<EOF
+CAIRN_MEMORY_EMBEDDING_URL=http://127.0.0.1:$port/v1
+CAIRN_MEMORY_EMBEDDING_MODEL=missing-model
+CAIRN_LLM_API_KEY=test-key
+EOF
+  if ( cd "$proj4" && "$doctor" ) >"$tmp/out4" 2>&1; then
+    fail "doctor should reject a missing embedding model:\n$(cat "$tmp/out4")"
+  fi
+  grep -q "\[FAIL\] embedding request failed for model missing-model" "$tmp/out4" ||
+    fail "expected a functional embedding FAIL line"
+fi
+
+echo "PASS: cairn doctor (skip unconfigured, fail unreachable, probe embeddings)"

package/templates/env.example.template

@@ -7,6 +7,7 @@
 # CAIRN_LLM_API_URL=https://api.openai.com/v1
 # CAIRN_LLM_EXTRACTION_MODEL=gpt-4o-mini
 # CAIRN_MEMORY_EMBEDDING_MODEL=text-embedding-3-small
+# CAIRN_MEMORY_EMBEDDING_TIMEOUT_MS=15000
 #
 # Git host for the collaboration commands (memory-sync, repo-review, security-audit).
 # One of: github | gitlab | codeberg | forgejo | none.  See docs/git-providers.md.