@lazyingart/agintiflow 0.1.0 → 0.2.0

package/web.js

@@ -7,17 +7,27 @@ import { resolveRuntimeConfig } from "./src/config.js";
 import { WebDatabase } from "./src/web-db.js";
 import { SessionStore } from "./src/session-store.js";
 import { getModelPresets, getProviderDefaults, normalizeRoutingMode } from "./src/model-routing.js";
-import { listAgentWrappers } from "./src/tool-wrappers.js";
+import { listAgentWrappers, normalizeWrapperName } from "./src/tool-wrappers.js";
 import { getDockerSandboxStatus, getSandboxLogs, runDockerPreflight } from "./src/docker-sandbox.js";
 import { normalizePackageInstallPolicy, normalizeSandboxMode } from "./src/command-policy.js";
+import { summarizeWorkspaceTools, WORKSPACE_TOOL_NAMES } from "./src/workspace-tools.js";
+import {
+  buildArtifacts,
+  countUnreadArtifacts,
+  findArtifact,
+  readArtifactContent,
+  serializeArtifacts,
+} from "./src/artifact-tunnel.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-const baseDir = process.cwd();
+const packageDir = __dirname;
+const baseDir = path.resolve(process.env.AGINTIFLOW_RUNTIME_DIR || process.cwd());
 const sessionsDir = path.join(baseDir, ".sessions");
 
 const app = express();
 const port = Number(process.env.PORT || 3210);
+const host = process.env.HOST || "127.0.0.1";
 const runs = new Map();
 const db = new WebDatabase(baseDir);
 const supportedLanguages = new Set([
@@ -43,6 +53,10 @@ function sessionStore(sessionId) {
   return new SessionStore(sessionsDir, sessionId);
 }
 
+function isSafeSessionId(sessionId) {
+  return /^[A-Za-z0-9._:-]+$/.test(String(sessionId || "")) && !String(sessionId || "").includes("..");
+}
+
 function mapEventLogs(events) {
   return events.map((event) => ({
     at: event.timestamp,
@@ -65,6 +79,7 @@ async function loadStoredRun(sessionId) {
     provider: meta.provider,
     model: meta.model,
     goal: meta.goal,
+    title: meta.title || "",
     startedAt: meta.startedAt,
     endedAt: meta.endedAt || null,
     result: meta.result || "",
@@ -80,6 +95,7 @@ function serializeRun(run) {
     provider: run.provider,
     model: run.model,
     goal: run.goal,
+    title: run.title || "",
     startedAt: run.startedAt,
     endedAt: run.endedAt || null,
     result: run.result || "",
@@ -90,13 +106,14 @@ function serializeRun(run) {
 
 function normalizePreferencePayload(body = {}, current = db.getPreferences()) {
   const modelPresets = getModelPresets();
-  const routingMode = normalizeRoutingMode(body.routingMode || current.routingMode || "smart");
-  const provider =
-    body.provider === "openai" || body.provider === "deepseek" ? body.provider : current.provider || "deepseek";
+  const providerCandidate = body.provider || current.provider || "deepseek";
+  const provider = ["openai", "deepseek", "mock"].includes(providerCandidate) ? providerCandidate : "deepseek";
+  const routingMode =
+    provider === "mock" ? "manual" : normalizeRoutingMode(body.routingMode || current.routingMode || "smart");
   const providerDefaults = getProviderDefaults(provider);
   const parsedMaxSteps = Number(body.maxSteps);
   const parsedWrapperTimeoutMs = Number(body.wrapperTimeoutMs);
-  const sandboxMode = normalizeSandboxMode(body.sandboxMode || current.sandboxMode || "docker-readonly");
+  const sandboxMode = normalizeSandboxMode(body.sandboxMode || current.sandboxMode || "docker-workspace");
 
   return {
     routingMode,
@@ -117,8 +134,10 @@ function normalizePreferencePayload(body = {}, current = db.getPreferences()) {
         ? body.commandCwd.trim()
         : current.commandCwd || path.resolve(baseDir, ".."),
     allowShellTool: typeof body.allowShellTool === "boolean" ? body.allowShellTool : Boolean(current.allowShellTool),
+    allowFileTools: typeof body.allowFileTools === "boolean" ? body.allowFileTools : current.allowFileTools !== false,
     allowWrapperTools:
       typeof body.allowWrapperTools === "boolean" ? body.allowWrapperTools : Boolean(current.allowWrapperTools),
+    preferredWrapper: normalizeWrapperName(body.preferredWrapper || current.preferredWrapper || "codex"),
     wrapperTimeoutMs:
       Number.isFinite(parsedWrapperTimeoutMs) && parsedWrapperTimeoutMs >= 10000
         ? parsedWrapperTimeoutMs
@@ -180,7 +199,9 @@ function buildRunConfig(body, overrides = {}) {
       allowPasswords: merged.allowPasswords,
       allowDestructive: merged.allowDestructive,
       allowShellTool: merged.allowShellTool,
+      allowFileTools: merged.allowFileTools,
       allowWrapperTools: merged.allowWrapperTools,
+      preferredWrapper: merged.preferredWrapper,
       wrapperTimeoutMs: merged.wrapperTimeoutMs,
       sandboxMode: merged.sandboxMode,
       packageInstallPolicy: merged.packageInstallPolicy,
@@ -188,6 +209,7 @@ function buildRunConfig(body, overrides = {}) {
       dockerSandboxImage: merged.dockerSandboxImage,
       commandCwd: merged.commandCwd,
       baseDir,
+      packageDir,
       sessionId: overrides.sessionId,
     }
   );
@@ -214,6 +236,7 @@ function deriveSessionRecordFromState(state, existing = null) {
     provider: state.provider || existing?.provider || "deepseek",
     model: state.model || existing?.model || getProviderDefaults(state.provider || existing?.provider || "deepseek").model,
     goal: state.goal || existing?.goal || "",
+    title: existing?.title || "",
     status,
     startedAt: state.createdAt || existing?.startedAt || new Date().toISOString(),
     updatedAt,
@@ -295,12 +318,35 @@ async function loadChat(sessionId) {
   return {
     sessionId,
     goal: state?.goal || meta?.goal || "",
+    title: meta?.title || "",
     provider: state?.provider || meta?.provider || "",
     model: state?.model || meta?.model || "",
     chat: deriveChatFromState(state, meta),
   };
 }
 
+function normalizeSessionTitle(title) {
+  return String(title || "")
+    .replace(/[\u0000-\u001f\u007f]/g, " ")
+    .replace(/\s+/g, " ")
+    .trim()
+    .slice(0, 90);
+}
+
+function autoSessionTitleFromChat(data) {
+  const candidate =
+    data?.chat?.find((entry) => entry.role === "user" && String(entry.content || "").trim())?.content ||
+    data?.goal ||
+    "Untitled conversation";
+  const cleaned = normalizeSessionTitle(candidate)
+    .replace(/^please\s+/i, "")
+    .replace(/^could you\s+/i, "")
+    .replace(/^can you\s+/i, "")
+    .replace(/^plz\s+/i, "")
+    .replace(/^i want to\s+/i, "");
+  return normalizeSessionTitle(cleaned.length > 72 ? `${cleaned.slice(0, 69).trim()}...` : cleaned) || "Untitled conversation";
+}
+
 async function ensureNotRunning(sessionId) {
   const inMemory = runs.get(sessionId);
   if (inMemory?.status === "running") {
@@ -313,6 +359,67 @@ async function ensureNotRunning(sessionId) {
   }
 }
 
+async function collectWorkspaceActivity(limit = 24) {
+  const activity = [];
+  const sessions = db.listSessions(30);
+
+  for (const session of sessions) {
+    const store = sessionStore(session.sessionId);
+    const events = await store.loadEvents();
+    for (const event of events) {
+      if (event.type === "file.changed") {
+        activity.push({
+          at: event.timestamp,
+          kind: "changed",
+          sessionId: session.sessionId,
+          goal: session.goal,
+          ...event.data,
+        });
+      }
+
+      if (
+        event.type === "tool.blocked" &&
+        (WORKSPACE_TOOL_NAMES.includes(event.data?.toolName) || WORKSPACE_TOOL_NAMES.includes(event.data?.args?.toolName))
+      ) {
+        activity.push({
+          at: event.timestamp,
+          kind: "blocked",
+          sessionId: session.sessionId,
+          goal: session.goal,
+          toolName: event.data?.toolName || "",
+          path: event.data?.args?.path || "",
+          reason: event.data?.reason || "",
+          category: event.data?.category || "",
+        });
+      }
+    }
+  }
+
+  return activity.sort((a, b) => String(b.at).localeCompare(String(a.at))).slice(0, limit);
+}
+
+async function loadArtifactBundle(sessionId) {
+  if (!isSafeSessionId(sessionId)) {
+    return { error: "Invalid session id.", status: 400 };
+  }
+
+  const meta = db.getSession(sessionId);
+  const store = sessionStore(sessionId);
+  const events = await store.loadEvents();
+  if (!meta && events.length === 0) {
+    return { error: "Session not found.", status: 404 };
+  }
+
+  const preferences = normalizePreferencePayload({}, db.getPreferences());
+  const config = buildRunConfig({ ...preferences, goal: "" });
+  const bundle = buildArtifacts({ sessionId, events, store });
+  return {
+    ...bundle,
+    store,
+    config,
+  };
+}
+
 function createRunRecord(config, goal, existingLogs = []) {
   return {
     sessionId: config.sessionId,
@@ -349,11 +456,15 @@ function wireRun(record, config) {
     onEvent: (type, data = {}) => push("event", type, data),
   })
     .then((result) => {
-      record.status = "finished";
+      record.status = result?.stopped ? "stopped" : "finished";
       record.result = result?.result || "";
+      record.error = result?.stopped ? result.reason || "Run stopped before finish." : "";
       record.updatedAt = new Date().toISOString();
       record.endedAt = new Date().toISOString();
-      push("session", "Run finished", { result: record.result });
+      push("session", result?.stopped ? "Run stopped" : "Run finished", {
+        result: record.result,
+        reason: result?.reason || "",
+      });
       db.upsertSession(record);
     })
     .catch((error) => {
@@ -370,12 +481,15 @@ app.use(express.json({ limit: "1mb" }));
 app.use(express.static(path.join(__dirname, "public")));
 app.use("/logos", express.static(path.join(__dirname, "logos")));
 
-app.get("/api/config", (_req, res) => {
+app.get("/api/config", async (_req, res) => {
+  await syncStoredSessions();
   const preferences = normalizePreferencePayload({}, db.getPreferences());
+  const config = buildRunConfig({ ...preferences, goal: "" });
   res.json({
     defaults: {
       openai: publicProviderDefault("openai"),
       deepseek: publicProviderDefault("deepseek"),
+      mock: publicProviderDefault("mock"),
       headless: true,
       maxSteps: 15,
     },
@@ -387,12 +501,14 @@ app.get("/api/config", (_req, res) => {
     sandbox: {
       logs: getSandboxLogs(),
     },
+    workspace: summarizeWorkspaceTools(config),
     preferences,
     keyStatus: {
       openai: Boolean(process.env.OPENAI_API_KEY),
       deepseek: Boolean(process.env.DEEPSEEK_API_KEY),
+      mock: true,
     },
-    sessions: db.listSessions(20),
+    sessions: db.listSessions(100),
   });
 });
 
@@ -419,8 +535,73 @@ app.post("/api/preferences", (req, res) => {
   res.json({ ok: true, preferences });
 });
 
-app.get("/api/sessions", (_req, res) => {
-  res.json({ sessions: db.listSessions(20) });
+app.get("/api/sessions", async (_req, res) => {
+  await syncStoredSessions();
+  res.json({ sessions: db.listSessions(100) });
+});
+
+app.get("/api/workspace/changes", async (_req, res) => {
+  const preferences = normalizePreferencePayload({}, db.getPreferences());
+  const config = buildRunConfig({ ...preferences, goal: "" });
+  res.json({
+    ok: true,
+    workspace: summarizeWorkspaceTools(config),
+    activity: await collectWorkspaceActivity(),
+  });
+});
+
+app.get("/api/sessions/:sessionId/artifacts", async (req, res) => {
+  const bundle = await loadArtifactBundle(req.params.sessionId);
+  if (bundle.error) {
+    res.status(bundle.status || 500).json({ error: bundle.error });
+    return;
+  }
+
+  res.json({
+    ok: true,
+    sessionId: req.params.sessionId,
+    items: serializeArtifacts(bundle.items),
+    selectedItemId: bundle.selectedItemId,
+    unreadCount: countUnreadArtifacts(bundle.items, req.query.seenAfter),
+  });
+});
+
+app.get("/api/sessions/:sessionId/artifacts/:artifactId", async (req, res) => {
+  const bundle = await loadArtifactBundle(req.params.sessionId);
+  if (bundle.error) {
+    res.status(bundle.status || 500).json({ error: bundle.error });
+    return;
+  }
+
+  const artifact = findArtifact(bundle.items, req.params.artifactId);
+  const content = await readArtifactContent(artifact, bundle);
+  if (!content.ok) {
+    res.status(artifact ? 400 : 404).json({ error: content.error || "Artifact not found." });
+    return;
+  }
+  res.json(content);
+});
+
+app.post("/api/sessions/:sessionId/artifacts/select", async (req, res) => {
+  const bundle = await loadArtifactBundle(req.params.sessionId);
+  if (bundle.error) {
+    res.status(bundle.status || 500).json({ error: bundle.error });
+    return;
+  }
+
+  const artifactId = String(req.body?.artifactId || "");
+  const artifact = findArtifact(bundle.items, artifactId);
+  if (!artifact) {
+    res.status(404).json({ error: "Artifact not found." });
+    return;
+  }
+
+  await sessionStore(req.params.sessionId).appendEvent("canvas.selected", {
+    artifactId,
+    title: artifact.title,
+    source: "user",
+  });
+  res.json({ ok: true, artifact: serializeArtifacts([artifact])[0] });
 });
 
 app.get("/api/sessions/:sessionId/chat", async (req, res) => {
@@ -432,6 +613,75 @@ app.get("/api/sessions/:sessionId/chat", async (req, res) => {
   res.json(data);
 });
 
+app.patch("/api/sessions/:sessionId", async (req, res) => {
+  const sessionId = req.params.sessionId;
+  if (!isSafeSessionId(sessionId)) {
+    res.status(400).json({ error: "Invalid session id." });
+    return;
+  }
+
+  const meta = db.getSession(sessionId);
+  if (!meta) {
+    res.status(404).json({ error: "Session not found." });
+    return;
+  }
+
+  const title = normalizeSessionTitle(req.body?.title);
+  if (!title) {
+    res.status(400).json({ error: "Title is required." });
+    return;
+  }
+
+  db.renameSession(sessionId, title);
+  await sessionStore(sessionId).appendEvent("session.renamed", { title }).catch(() => {});
+  res.json({ ok: true, session: db.getSession(sessionId) });
+});
+
+app.post("/api/sessions/:sessionId/auto-title", async (req, res) => {
+  const sessionId = req.params.sessionId;
+  if (!isSafeSessionId(sessionId)) {
+    res.status(400).json({ error: "Invalid session id." });
+    return;
+  }
+
+  const data = await loadChat(sessionId);
+  if (!data) {
+    res.status(404).json({ error: "Session not found." });
+    return;
+  }
+
+  const title = autoSessionTitleFromChat(data);
+  db.renameSession(sessionId, title);
+  await sessionStore(sessionId).appendEvent("session.auto_renamed", { title }).catch(() => {});
+  res.json({ ok: true, session: db.getSession(sessionId) });
+});
+
+app.delete("/api/sessions/:sessionId", async (req, res) => {
+  const sessionId = req.params.sessionId;
+  if (!isSafeSessionId(sessionId)) {
+    res.status(400).json({ error: "Invalid session id." });
+    return;
+  }
+
+  try {
+    await ensureNotRunning(sessionId);
+  } catch (error) {
+    res.status(409).json({ error: error instanceof Error ? error.message : String(error) });
+    return;
+  }
+
+  const meta = db.getSession(sessionId);
+  if (!meta) {
+    res.status(404).json({ error: "Session not found." });
+    return;
+  }
+
+  runs.delete(sessionId);
+  db.deleteSession(sessionId);
+  await sessionStore(sessionId).remove();
+  res.json({ ok: true, sessionId });
+});
+
 app.post("/api/runs", async (req, res) => {
   const body = req.body || {};
   const goal = String(body.goal || "").trim();
@@ -523,8 +773,9 @@ app.get("/health", (_req, res) => {
   res.json({ ok: true, port });
 });
 
+await fs.mkdir(sessionsDir, { recursive: true });
 await syncStoredSessions();
 
-app.listen(port, () => {
-  console.log(`Website control agent UI running on http://127.0.0.1:${port}`);
+app.listen(port, host, () => {
+  console.log(`Website control agent UI running on http://${host}:${port}`);
 });