@lazyingart/agintiflow 0.1.0 → 0.3.0

package/scripts/setup-agent-toolchain-docker.sh

@@ -0,0 +1,51 @@
+#!/usr/bin/env bash
+set -Eeuo pipefail
+
+SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(cd -- "${SCRIPT_DIR}/.." && pwd)"
+IMAGE="${AGINTIFLOW_TOOLCHAIN_IMAGE:-agintiflow-sandbox:latest}"
+WORKSPACE="${AGINTIFLOW_TOOLCHAIN_WORKSPACE:-${REPO_ROOT}}"
+DOCKERFILE="${AGINTIFLOW_TOOLCHAIN_DOCKERFILE:-${REPO_ROOT}/docker/sandbox.Dockerfile}"
+
+if ! command -v docker >/dev/null 2>&1; then
+  echo "Docker is not installed or not on PATH. Run scripts/install-docker-ubuntu.sh first." >&2
+  exit 1
+fi
+
+mkdir -p "${WORKSPACE}"
+
+echo "Building AgInTiFlow toolchain sandbox image:"
+echo "  image=${IMAGE}"
+echo "  dockerfile=${DOCKERFILE}"
+echo "  context=${REPO_ROOT}"
+docker build -t "${IMAGE}" -f "${DOCKERFILE}" "${REPO_ROOT}"
+
+echo
+echo "Running toolchain preflight inside Docker:"
+docker run --rm \
+  --network none \
+  --cap-drop ALL \
+  --security-opt no-new-privileges \
+  --pids-limit 256 \
+  --memory 2g \
+  --cpus 2 \
+  --tmpfs /tmp:rw,nosuid,nodev,size=512m \
+  -e HOME=/tmp \
+  -v "${WORKSPACE}:/workspace:rw" \
+  -w /workspace \
+  "${IMAGE}" \
+  bash -lc 'set -Eeuo pipefail
+    node -v
+    npm -v
+    python3 --version
+    python3 - <<PY
+import matplotlib, numpy
+print("matplotlib", matplotlib.__version__)
+print("numpy", numpy.__version__)
+PY
+    latexmk -version | head -1
+    pdflatex --version | head -1
+  '
+
+echo
+echo "Toolchain sandbox is ready."

package/scripts/smoke-coding-tools.js

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { repairModelMessageHistory, runAgent } from "../src/agent-runner.js";
+import { resolveRuntimeConfig } from "../src/config.js";
+import { SessionStore } from "../src/session-store.js";
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "agintiflow-coding-tools-"));
+const runtimeDir = path.join(tempRoot, "runtime");
+const workspace = path.join(tempRoot, "workspace");
+await fs.mkdir(workspace, { recursive: true });
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+async function runMock(goal, sessionId) {
+  const config = resolveRuntimeConfig(
+    {
+      provider: "mock",
+      routingMode: "manual",
+      model: "mock-agent",
+      goal,
+      commandCwd: workspace,
+      maxSteps: 5,
+    },
+    {
+      baseDir: runtimeDir,
+      packageDir: repoRoot,
+      provider: "mock",
+      routingMode: "manual",
+      model: "mock-agent",
+      commandCwd: workspace,
+      allowShellTool: false,
+      allowFileTools: true,
+      sandboxMode: "host",
+      packageInstallPolicy: "block",
+      sessionId,
+    }
+  );
+
+  const result = await runAgent(config);
+  const store = new SessionStore(config.sessionsDir, result.sessionId);
+  return {
+    result,
+    events: await store.loadEvents(),
+  };
+}
+
+try {
+  const staleDeepSeekState = {
+    messages: [
+      { role: "system", content: "system" },
+      { role: "user", content: "draw a figure" },
+      { role: "assistant", content: "Execution plan:\n1. stale synthetic plan" },
+      {
+        role: "assistant",
+        content: "I will call a tool.",
+        tool_calls: [{ id: "stale-call", type: "function", function: { name: "list_files", arguments: "{}" } }],
+      },
+      { role: "tool", tool_call_id: "stale-call", content: "{\"ok\":true}" },
+      { role: "assistant", content: "Old final answer." },
+    ],
+  };
+  const repair = repairModelMessageHistory(staleDeepSeekState, { provider: "deepseek" });
+  assert(repair.changed, "stale DeepSeek history was not repaired");
+  assert(
+    staleDeepSeekState.messages.every(
+      (message) => message.role !== "assistant" || message.reasoning_content || message.reasoningContent
+    ),
+    "repaired DeepSeek history still has assistant messages without reasoning_content"
+  );
+  assert(
+    !staleDeepSeekState.messages.some((message) => message.role === "tool" && message.tool_call_id === "stale-call"),
+    "repaired DeepSeek history retained an orphan stale tool message"
+  );
+
+  const writeRun = await runMock("Create file: notes/mock-output.txt with a short coding smoke message.", "coding-write");
+  const written = await fs.readFile(path.join(workspace, "notes/mock-output.txt"), "utf8");
+  assert(written.includes("Created by AgInTiFlow mock mode."), "mock write did not create expected file");
+  assert(writeRun.events.some((event) => event.type === "file.changed"), "write run did not persist file.changed event");
+
+  await runMock("Create file: /workspace/virtual-output.txt with virtual Docker path support.", "coding-write-virtual");
+  const virtualWritten = await fs.readFile(path.join(workspace, "virtual-output.txt"), "utf8");
+  assert(virtualWritten.includes("Created by AgInTiFlow mock mode."), "virtual /workspace path was not mapped safely");
+
+  await fs.writeFile(path.join(workspace, "patch-target.txt"), "old\n", "utf8");
+  const patchRun = await runMock("Patch file: patch-target.txt replace old with new.", "coding-patch");
+  const patched = await fs.readFile(path.join(workspace, "patch-target.txt"), "utf8");
+  assert(patched === "new\n", "mock patch did not update expected file");
+  assert(patchRun.events.some((event) => event.type === "file.changed"), "patch run did not persist file.changed event");
+
+  const envRun = await runMock("Create file: .env with blocked content.", "coding-block-env");
+  await fs
+    .access(path.join(workspace, ".env"))
+    .then(() => {
+      throw new Error(".env was created despite path guardrails");
+    })
+    .catch((error) => {
+      if (error.code !== "ENOENT") throw error;
+    });
+  assert(envRun.events.some((event) => event.type === "tool.blocked"), ".env guardrail did not emit tool.blocked");
+
+  const outsideRun = await runMock("Create file: ../outside-workspace.txt with blocked content.", "coding-block-outside");
+  await fs
+    .access(path.join(tempRoot, "outside-workspace.txt"))
+    .then(() => {
+      throw new Error("outside-workspace.txt was created despite path guardrails");
+    })
+    .catch((error) => {
+      if (error.code !== "ENOENT") throw error;
+    });
+  assert(outsideRun.events.some((event) => event.type === "tool.blocked"), "outside path guardrail did not emit tool.blocked");
+
+  console.log(
+    JSON.stringify(
+      {
+        ok: true,
+        workspace,
+        checks: [
+          "deepseek_history_repair",
+          "write_file",
+          "virtual_workspace_path",
+          "apply_patch",
+          "block_env",
+          "block_outside",
+        ],
+      },
+      null,
+      2
+    )
+  );
+} finally {
+  await fs.rm(tempRoot, { recursive: true, force: true });
+}

package/scripts/smoke-toolchain-docker.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { readArtifactContent } from "../src/artifact-tunnel.js";
+import { evaluateCommandPolicy } from "../src/command-policy.js";
+import { runDockerPreflight, runDockerSandboxCommand } from "../src/docker-sandbox.js";
+import { resolveRuntimeConfig } from "../src/config.js";
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "agintiflow-toolchain-"));
+const runtimeDir = path.join(tempRoot, "runtime");
+const workspace = path.join(tempRoot, "workspace");
+await fs.mkdir(workspace, { recursive: true });
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+async function runToolchainCommand(command, config) {
+  const policy = evaluateCommandPolicy(command, config);
+  assert(policy.allowed, `${command} was blocked: ${policy.reason || policy.category}`);
+  return runDockerSandboxCommand(command, config, policy);
+}
+
+try {
+  const config = resolveRuntimeConfig(
+    {
+      provider: "mock",
+      routingMode: "manual",
+      model: "mock-agent",
+      goal: "",
+      commandCwd: workspace,
+      maxSteps: 1,
+    },
+    {
+      baseDir: runtimeDir,
+      packageDir: repoRoot,
+      provider: "mock",
+      routingMode: "manual",
+      model: "mock-agent",
+      commandCwd: workspace,
+      allowShellTool: true,
+      allowFileTools: true,
+      useDockerSandbox: true,
+      sandboxMode: "docker-workspace",
+      packageInstallPolicy: "block",
+      dockerSandboxImage: process.env.AGINTIFLOW_TOOLCHAIN_IMAGE || "agintiflow-sandbox:latest",
+    }
+  );
+
+  const preflight = await runDockerPreflight(config, { buildImage: false });
+  assert(preflight.ok, "Docker toolchain preflight failed. Run scripts/setup-agent-toolchain-docker.sh first.");
+
+  await fs.writeFile(
+    path.join(workspace, "plot_fx.py"),
+    [
+      "import math",
+      "import matplotlib",
+      "matplotlib.use('Agg')",
+      "import matplotlib.pyplot as plt",
+      "xs = [x / 20 for x in range(-60, 61)]",
+      "ys = [x + math.exp(x) for x in xs]",
+      "fig, ax = plt.subplots(figsize=(7, 4.4), dpi=160)",
+      "ax.plot(xs, ys, color='#0065c9', linewidth=2.5)",
+      "ax.axhline(0, color='#6b7280', linewidth=0.8)",
+      "ax.axvline(0, color='#6b7280', linewidth=0.8)",
+      "ax.grid(True, alpha=0.25)",
+      "ax.set_title('f(x) = x + e^x')",
+      "ax.set_xlabel('x')",
+      "ax.set_ylabel('f(x)')",
+      "fig.tight_layout()",
+      "fig.savefig('plot_fx.svg')",
+      "",
+    ].join("\n"),
+    "utf8"
+  );
+  await runToolchainCommand("python3 plot_fx.py", config);
+  const svg = await fs.readFile(path.join(workspace, "plot_fx.svg"), "utf8");
+  assert(svg.includes("<svg"), "Python plot did not produce an SVG file");
+
+  await fs.writeFile(
+    path.join(workspace, "paper.tex"),
+    [
+      "\\documentclass{article}",
+      "\\usepackage[T1]{fontenc}",
+      "\\usepackage{amsmath}",
+      "\\title{AgInTiFlow Toolchain Smoke}",
+      "\\author{AgInTiFlow}",
+      "\\date{}",
+      "\\begin{document}",
+      "\\maketitle",
+      "This smoke test verifies that the companion Docker sandbox can compile a PDF.",
+      "\\[ f(x) = x + e^x, \\qquad f'(x) = 1 + e^x. \\]",
+      "\\end{document}",
+      "",
+    ].join("\n"),
+    "utf8"
+  );
+  await runToolchainCommand("latexmk -pdf -interaction=nonstopmode -halt-on-error paper.tex", config);
+  const pdfStat = await fs.stat(path.join(workspace, "paper.pdf"));
+  assert(pdfStat.size > 1000, "LaTeX did not produce a useful PDF file");
+
+  const pdfPreview = await readArtifactContent(
+    {
+      id: "smoke-pdf",
+      kind: "pdf",
+      title: "Toolchain PDF",
+      path: "paper.pdf",
+      ref: { type: "workspace-file", path: "paper.pdf", commandCwd: workspace },
+    },
+    { config }
+  );
+  assert(pdfPreview.ok && pdfPreview.kind === "pdf", "PDF artifact preview was not renderable");
+  assert(/^data:application\/pdf;base64,/.test(pdfPreview.dataUrl || ""), "PDF artifact did not return a PDF data URL");
+
+  await fs.mkdir(path.join(workspace, "figure-note"), { recursive: true });
+  await fs.writeFile(
+    path.join(workspace, "figure-note", "make_figure.py"),
+    [
+      "import math",
+      "import matplotlib",
+      "matplotlib.use('Agg')",
+      "import matplotlib.pyplot as plt",
+      "xs = [x / 20 for x in range(-40, 41)]",
+      "ys = [x + math.exp(x) for x in xs]",
+      "fig, ax = plt.subplots(figsize=(6, 3.5))",
+      "ax.plot(xs, ys, color='#0065c9', linewidth=2.2)",
+      "ax.set_title('f(x)=x+e^x')",
+      "ax.set_xlabel('x')",
+      "ax.set_ylabel('f(x)')",
+      "ax.grid(True, alpha=0.25)",
+      "fig.tight_layout()",
+      "fig.savefig('figure-note/fx_figure.pdf')",
+      "",
+    ].join("\n"),
+    "utf8"
+  );
+  await runToolchainCommand("python3 figure-note/make_figure.py", config);
+
+  await fs.writeFile(
+    path.join(workspace, "figure-note", "figure_note.tex"),
+    [
+      "\\documentclass{article}",
+      "\\usepackage[T1]{fontenc}",
+      "\\usepackage{amsmath}",
+      "\\usepackage{graphicx}",
+      "\\title{Figure-Included Toolchain Smoke}",
+      "\\author{AgInTiFlow}",
+      "\\date{}",
+      "\\begin{document}",
+      "\\maketitle",
+      "The generated figure below is included from a workspace subfolder.",
+      "\\[ f(x)=x+e^x \\]",
+      "\\begin{figure}[h]",
+      "\\centering",
+      "\\includegraphics[width=0.8\\linewidth]{fx_figure.pdf}",
+      "\\caption{Generated plot of $f(x)=x+e^x$.}",
+      "\\end{figure}",
+      "\\end{document}",
+      "",
+    ].join("\n"),
+    "utf8"
+  );
+  await runToolchainCommand("latexmk -cd -pdf -interaction=nonstopmode -halt-on-error figure-note/figure_note.tex", config);
+  const figureNotePdf = await fs.stat(path.join(workspace, "figure-note", "figure_note.pdf"));
+  assert(figureNotePdf.size > 1000, "Figure-included LaTeX note did not produce a PDF file");
+
+  console.log(
+    JSON.stringify(
+      {
+        ok: true,
+        image: config.dockerSandboxImage,
+        workspace,
+        outputs: ["plot_fx.svg", "paper.pdf", "figure-note/fx_figure.pdf", "figure-note/figure_note.pdf"],
+        artifactKinds: ["image/svg+xml", "application/pdf"],
+      },
+      null,
+      2
+    )
+  );
+} finally {
+  await fs.rm(tempRoot, { recursive: true, force: true });
+}

package/scripts/smoke-web-api.js

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const runtimeDir = await fs.mkdtemp(path.join(os.tmpdir(), "agintiflow-api-smoke-"));
+const port = 43000 + Math.floor(Math.random() * 1000);
+const baseUrl = `http://127.0.0.1:${port}`;
+const server = spawn(process.execPath, [path.join(repoRoot, "web.js")], {
+  cwd: runtimeDir,
+  env: {
+    ...process.env,
+    PORT: String(port),
+    HOST: "127.0.0.1",
+    AGINTIFLOW_RUNTIME_DIR: runtimeDir,
+  },
+  stdio: ["ignore", "pipe", "pipe"],
+});
+
+let stdout = "";
+let stderr = "";
+server.stdout.on("data", (chunk) => {
+  stdout += chunk.toString();
+});
+server.stderr.on("data", (chunk) => {
+  stderr += chunk.toString();
+});
+
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function fetchJson(pathname, options = {}) {
+  const response = await fetch(`${baseUrl}${pathname}`, options);
+  const body = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    throw new Error(`${pathname} failed with ${response.status}: ${body.error || response.statusText}`);
+  }
+  return body;
+}
+
+async function waitForHealth() {
+  const deadline = Date.now() + 15000;
+  while (Date.now() < deadline) {
+    if (server.exitCode !== null) break;
+    try {
+      const health = await fetchJson("/health");
+      if (health.ok) return health;
+    } catch {
+      await delay(250);
+    }
+  }
+
+  throw new Error(`web server did not become healthy. stdout=${stdout.slice(-500)} stderr=${stderr.slice(-500)}`);
+}
+
+async function waitForRun(sessionId) {
+  const deadline = Date.now() + 20000;
+  while (Date.now() < deadline) {
+    const run = await fetchJson(`/api/runs/${encodeURIComponent(sessionId)}`);
+    if (run.status === "finished" || run.status === "failed") return run;
+    await delay(400);
+  }
+  throw new Error(`run ${sessionId} did not finish in time`);
+}
+
+try {
+  await waitForHealth();
+
+  const config = await fetchJson("/api/config");
+  if (!config.keyStatus?.mock) throw new Error("mock provider is not advertised by /api/config");
+  if (!config.workspace?.enabled) throw new Error("workspace file tools are not advertised by /api/config");
+  if (config.preferences?.preferredWrapper !== "codex") throw new Error("Codex is not the default preferred wrapper");
+
+  const status = await fetchJson("/api/sandbox/status");
+  if (!status.status?.workspaceReadable) throw new Error("sandbox status did not report a readable workspace");
+
+  const preflight = await fetchJson("/api/sandbox/preflight", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      sandboxMode: "host",
+      commandCwd: runtimeDir,
+      buildImage: false,
+    }),
+  });
+  if (!preflight.ok) throw new Error("host preflight did not pass");
+
+  const runStart = await fetchJson("/api/runs", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      provider: "mock",
+      routingMode: "manual",
+      model: "mock-agent",
+      goal: "Report the current working directory with a safe command.",
+      commandCwd: runtimeDir,
+      sandboxMode: "host",
+      packageInstallPolicy: "block",
+      allowShellTool: true,
+      preferredWrapper: "codex",
+      maxSteps: 4,
+      headless: true,
+    }),
+  });
+
+  const run = await waitForRun(runStart.sessionId);
+  if (run.status !== "finished") throw new Error(`mock run failed: ${run.error || "unknown error"}`);
+  if (!/Mock run complete/.test(run.result)) throw new Error("mock run did not return the expected result");
+
+  const chat = await fetchJson(`/api/sessions/${encodeURIComponent(runStart.sessionId)}/chat`);
+  if (!Array.isArray(chat.chat) || chat.chat.length < 2) throw new Error("chat history was not persisted");
+
+  const renamed = await fetchJson(`/api/sessions/${encodeURIComponent(runStart.sessionId)}`, {
+    method: "PATCH",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ title: "Smoke renamed conversation" }),
+  });
+  if (renamed.session?.title !== "Smoke renamed conversation") throw new Error("session rename did not persist");
+
+  const autoRenamed = await fetchJson(`/api/sessions/${encodeURIComponent(runStart.sessionId)}/auto-title`, {
+    method: "POST",
+  });
+  if (!/^Report the current working directory/i.test(autoRenamed.session?.title || "")) {
+    throw new Error("session auto rename did not derive a title from chat history");
+  }
+
+  const changes = await fetchJson("/api/workspace/changes");
+  if (!Array.isArray(changes.activity)) throw new Error("workspace changes endpoint returned an invalid payload");
+
+  const canvasRunStart = await fetchJson("/api/runs", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      provider: "mock",
+      routingMode: "manual",
+      model: "mock-agent",
+      goal: "Create a canvas artifact preview for this smoke test.",
+      commandCwd: runtimeDir,
+      sandboxMode: "host",
+      packageInstallPolicy: "block",
+      allowShellTool: false,
+      allowFileTools: true,
+      preferredWrapper: "codex",
+      maxSteps: 4,
+      headless: true,
+    }),
+  });
+  const canvasRun = await waitForRun(canvasRunStart.sessionId);
+  if (canvasRun.status !== "finished") throw new Error(`mock canvas run failed: ${canvasRun.error || "unknown error"}`);
+
+  const artifacts = await fetchJson(`/api/sessions/${encodeURIComponent(canvasRunStart.sessionId)}/artifacts`);
+  if (!Array.isArray(artifacts.items) || artifacts.items.length === 0) {
+    throw new Error("artifact endpoint returned no items for a finished mock run");
+  }
+  if (!artifacts.items.some((item) => item.source === "agent-canvas")) {
+    throw new Error("mock run did not publish an agent canvas artifact");
+  }
+  const selectedArtifactId = artifacts.selectedItemId || artifacts.items[0].id;
+  const selected = await fetchJson(`/api/sessions/${encodeURIComponent(canvasRunStart.sessionId)}/artifacts/select`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ artifactId: selectedArtifactId }),
+  });
+  if (!selected.ok) throw new Error("artifact selection endpoint failed");
+  const artifactContent = await fetchJson(
+    `/api/sessions/${encodeURIComponent(canvasRunStart.sessionId)}/artifacts/${encodeURIComponent(selectedArtifactId)}`
+  );
+  if (!artifactContent.text && !artifactContent.dataUrl) {
+    throw new Error("artifact content endpoint did not return renderable content");
+  }
+
+  const deleted = await fetchJson(`/api/sessions/${encodeURIComponent(runStart.sessionId)}`, {
+    method: "DELETE",
+  });
+  if (!deleted.ok) throw new Error("session delete failed");
+
+  const canvasDeleted = await fetchJson(`/api/sessions/${encodeURIComponent(canvasRunStart.sessionId)}`, {
+    method: "DELETE",
+  });
+  if (!canvasDeleted.ok) throw new Error("canvas session delete failed");
+
+  console.log(
+    JSON.stringify(
+      {
+        ok: true,
+        endpoints: [
+          "/api/config",
+          "/api/sandbox/status",
+          "/api/sandbox/preflight",
+          "/api/runs",
+          "/api/sessions/:id/chat",
+          "PATCH /api/sessions/:id",
+          "POST /api/sessions/:id/auto-title",
+          "DELETE /api/sessions/:id",
+          "/api/workspace/changes",
+          "/api/sessions/:id/artifacts",
+          "/api/sessions/:id/artifacts/:artifactId",
+          "POST /api/sessions/:id/artifacts/select",
+        ],
+        provider: run.provider,
+        model: run.model,
+        sessionId: run.sessionId,
+        runtimeDir,
+      },
+      null,
+      2
+    )
+  );
+} finally {
+  server.kill("SIGTERM");
+  await delay(150);
+  await fs.rm(runtimeDir, { recursive: true, force: true });
+}