@agentrific/server 0.4.0 → 0.5.1

package/index.js

@@ -1,27 +1,7 @@
-// src/warnings.ts
-var handlers = process.rawListeners("warning");
-process.removeAllListeners("warning");
-process.on("warning", (warning) => {
-  if (warning.name === "ExperimentalWarning" && warning.message === "SQLite is an experimental feature and might change at any time")
-    return;
-  for (const handler of handlers) handler.call(process, warning);
-});
-
-// src/push.ts
-import {
-  generateKeyPairSync,
-  createPrivateKey,
-  createPublicKey,
-  sign,
-  randomUUID
-} from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import path from "node:path";
-import { Effect } from "effect";
-
 // ../../packages/contracts/src/push.ts
 import { z } from "zod";
 var PUSH_API_URL = "https://api.agentrific.com";
+var PUSH_SANDBOX_API_URL = "https://sandbox-api.agentrific.com";
 var PushKindSchema = z.enum([
   "started",
   "completed",
@@ -85,7 +65,26 @@ function pushSigningText(installationId, operation, request) {
   ].join("\n");
 }
 
+// src/warnings.ts
+var handlers = process.rawListeners("warning");
+process.removeAllListeners("warning");
+process.on("warning", (warning) => {
+  if (warning.name === "ExperimentalWarning" && warning.message === "SQLite is an experimental feature and might change at any time")
+    return;
+  for (const handler of handlers) handler.call(process, warning);
+});
+
 // src/push.ts
+import {
+  generateKeyPairSync,
+  createPrivateKey,
+  createPublicKey,
+  sign,
+  randomUUID
+} from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { Effect } from "effect";
 function pushKind(session, previous) {
   if (session.gitDelivery?.status === "pr_opened" && previous?.gitDelivery?.status !== "pr_opened")
     return "pr_created";
@@ -586,11 +585,25 @@ var ConnectionsStatusSchema = z2.object({
   githubCli: z2.object({ installed: z2.boolean(), authenticated: z2.boolean() })
 });
 var UpdateSettingsSchema = z2.object({ projectsRoot: z2.string().trim().min(1).max(4096) });
+var RepositoryIdentitySchema = z2.object({
+  key: z2.string(),
+  display: z2.string()
+});
+var ProjectGitStatusSchema = z2.object({
+  observedAt: z2.string().datetime(),
+  state: z2.enum(["available", "unavailable"]),
+  repository: RepositoryIdentitySchema.nullable(),
+  head: z2.string().nullable(),
+  branch: z2.string().nullable(),
+  trackedChanges: z2.number().int().nonnegative(),
+  untrackedChanges: z2.number().int().nonnegative()
+});
 var ProjectSchema = z2.object({
   id: z2.string(),
   name: z2.string(),
   path: z2.string(),
-  available: z2.boolean().default(true)
+  available: z2.boolean().default(true),
+  repository: RepositoryIdentitySchema.nullable().optional()
 });
 var TaskStatusSchema = z2.enum(["backlog", "needs_user_input", "running", "done"]);
 var TaskSchema = z2.object({
@@ -609,6 +622,7 @@ var TaskSchema = z2.object({
   deletedAt: z2.string().datetime().optional()
 });
 var CreateTaskSchema = z2.object({
+  clientTaskId: z2.string().min(1).max(128).regex(/^[a-zA-Z0-9_-]+$/).optional(),
   projectId: z2.string().min(1),
   title: z2.string().trim().min(1).max(120),
   prompt: z2.string().trim().max(2e4).default(""),
@@ -871,8 +885,8 @@ var Attachments = class extends Context.Service()(
 
 // src/index.ts
 import { randomUUID as randomUUID9 } from "node:crypto";
-import { execFile as execFile2 } from "node:child_process";
-import { promisify as promisify2 } from "node:util";
+import { execFile as execFile3 } from "node:child_process";
+import { promisify as promisify3 } from "node:util";
 import { realpath as realpath2 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
 import path9 from "node:path";
@@ -1097,7 +1111,7 @@ async function startControl(directory, security2, status, maintenance2) {
 // package.json
 var package_default = {
   name: "@agentrific/server",
-  version: "0.4.0",
+  version: "0.5.1",
   description: "Self-hosted control plane for long-running coding agents",
   keywords: [
     "agentrific",
@@ -1608,7 +1622,7 @@ function editTask(store2, id, input, resolveAttachments) {
   });
 }
 function deleteTask(store2, id, cleanup = async () => {
-}) {
+}, unrunUpdatedAt) {
   return withTaskLock(id, async () => {
     const task = await findTask(store2, id);
     const sessions = await Effect6.runPromise(store2.list());
@@ -1619,6 +1633,8 @@ function deleteTask(store2, id, cleanup = async () => {
     const associated = sessions.filter(
       (session) => session.taskId === task.id || session.id === task.sessionId
     );
+    if (unrunUpdatedAt !== void 0 && (task.updatedAt !== unrunUpdatedAt || task.sessionId || associated.length || task.status !== "backlog"))
+      throw new TaskActionError("This task changed or has already run. It cannot be moved.", 409);
     for (const session of associated) await cleanup(session);
     await Effect6.runPromise(
       store2.purgeTask(
@@ -2027,7 +2043,7 @@ var exec = promisify(execFile);
 function workflowLog(text) {
   return stripVTControlCharacters(text).slice(-32e3);
 }
-async function workflowCommand(cwd, command, args, signal, managedPreparation = false) {
+function workflowEnvironment() {
   const env = { ...process.env };
   for (const name of [
     "GIT_DIR",
@@ -2047,6 +2063,10 @@ async function workflowCommand(cwd, command, args, signal, managedPreparation =
     "GIT_REPLACE_REF_BASE"
   ])
     delete env[name];
+  return env;
+}
+async function workflowCommand(cwd, command, args, signal, managedPreparation = false) {
+  const env = workflowEnvironment();
   if (managedPreparation) env.AGENTRIFIC_MANAGED_PREPARATION = "1";
   const result = await exec(command, args, {
     cwd,
@@ -3211,6 +3231,106 @@ function reconnectProject(root, id, input, store2) {
   }).pipe(projectLock(store2).withPermit);
 }
 
+// src/project-git.ts
+import { execFile as execFile2 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+var execute = promisify2(execFile2);
+function repositoryIdentity(remote) {
+  const input = remote.trim();
+  if (!input || input.startsWith("/") || input.startsWith(".")) return null;
+  const scp = /^(?:[^@/\s]+@)?([^/:\s]+):([^\s]+)$/.exec(input);
+  let url;
+  try {
+    url = new URL(scp && !input.includes("://") ? `ssh://${scp[1]}/${scp[2]}` : input);
+  } catch {
+    return null;
+  }
+  if (!["https:", "http:", "ssh:", "git:"].includes(url.protocol)) return null;
+  if (url.search || url.hash || url.port) return null;
+  const host2 = url.hostname.toLowerCase();
+  let path10 = url.pathname.replace(/^\/+|\/+$/g, "").replace(/\.git$/, "");
+  if (!host2 || !path10 || path10.includes("%") || path10.includes("//")) return null;
+  if (["github.com", "bitbucket.org"].includes(host2)) path10 = path10.toLowerCase();
+  const key = `${host2}/${path10}`;
+  return { key, display: key };
+}
+async function git(directory, args) {
+  const { stdout } = await execute("git", ["-C", directory, ...args], {
+    timeout: 3e3,
+    maxBuffer: 1024 * 1024,
+    env: { ...workflowEnvironment(), GIT_OPTIONAL_LOCKS: "0", GIT_TERMINAL_PROMPT: "0" }
+  });
+  return stdout.trim();
+}
+async function readRepositoryIdentity(directory) {
+  try {
+    const remotes = (await git(directory, ["remote"])).split("\n").filter(Boolean);
+    const remote = remotes.includes("origin") ? "origin" : remotes.length === 1 ? remotes[0] : null;
+    if (!remote) return null;
+    return repositoryIdentity(await git(directory, ["remote", "get-url", remote]));
+  } catch {
+    return null;
+  }
+}
+async function inspect(directory) {
+  const observedAt = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    const [repository, head, branch, status] = await Promise.all([
+      readRepositoryIdentity(directory),
+      git(directory, ["rev-parse", "--verify", "HEAD"]),
+      git(directory, ["symbolic-ref", "--quiet", "--short", "HEAD"]).catch(() => null),
+      // NUL-separated records avoid ambiguous filenames/newlines. --no-renames
+      // keeps each entry one record, so we only need its two status characters.
+      execute(
+        "git",
+        [
+          "-C",
+          directory,
+          "status",
+          "--porcelain=v1",
+          "-z",
+          "--no-renames",
+          "--untracked-files=normal"
+        ],
+        {
+          timeout: 3e3,
+          maxBuffer: 1024 * 1024,
+          env: { ...workflowEnvironment(), GIT_OPTIONAL_LOCKS: "0" }
+        }
+      )
+    ]);
+    const records = status.stdout.split("\0").filter(Boolean);
+    return {
+      observedAt,
+      state: "available",
+      repository,
+      head,
+      branch,
+      trackedChanges: records.filter((record) => !record.startsWith("??")).length,
+      untrackedChanges: records.filter((record) => record.startsWith("??")).length
+    };
+  } catch {
+    return {
+      observedAt,
+      state: "unavailable",
+      repository: null,
+      head: null,
+      branch: null,
+      trackedChanges: 0,
+      untrackedChanges: 0
+    };
+  }
+}
+var observations = /* @__PURE__ */ new Map();
+function projectGitStatus(directory) {
+  const cached = observations.get(directory);
+  if (cached && cached.expires > Date.now()) return cached.value;
+  if (observations.size >= 200) observations.delete(observations.keys().next().value);
+  const value = inspect(directory);
+  observations.set(directory, { expires: Date.now() + 15e3, value });
+  return value;
+}
+
 // src/store.ts
 import { chmodSync, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "node:fs";
 import path7 from "node:path";
@@ -3777,7 +3897,7 @@ var defaultProjectsRoot = path9.resolve(process.env.AGENTRIFIC_PROJECTS_DIR ?? "
 var worktreesRoot = path9.resolve(
   process.env.AGENTRIFIC_WORKTREES_DIR ?? path9.join(homedir2(), ".agentrific", "workspaces")
 );
-var execFileAsync = promisify2(execFile2);
+var execFileAsync = promisify3(execFile3);
 if (host !== "127.0.0.1" && host !== "::1")
   throw new Error("Bind Agentrific to loopback and expose it with Tailscale Serve or cloudflared.");
 var app = Fastify({
@@ -3803,10 +3923,19 @@ var releaseLock = await acquireServerLock(dataRoot);
 var effects = ManagedRuntime.make(SessionStore.layer(path9.join(dataRoot, "sessions.sqlite")));
 var store = await effects.runPromise(SessionStore);
 var security = new ServerSecurity(store, await Effect17.runPromise(store.serverIdentity()));
+var sandboxPushUrl = process.env.AGENTRIFIC_PUSH_SANDBOX === "1" ? PUSH_SANDBOX_API_URL : void 0;
+if (sandboxPushUrl && process.env.AGENTRIFIC_TEST_MODE !== "1")
+  throw new Error("Sandbox push requires explicit test mode.");
 var testPushUrl = process.env.AGENTRIFIC_PUSH_TEST_URL;
 if (testPushUrl && (process.env.AGENTRIFIC_TEST_MODE !== "1" || !new URL(testPushUrl).hostname.endsWith(".ts.net") || new URL(testPushUrl).protocol !== "https:"))
   throw new Error("Test relay requires explicit test mode and Tailscale HTTPS.");
-var push = new ServerPush(store, security.serverId, dataRoot, fetch, testPushUrl);
+var push = new ServerPush(
+  store,
+  security.serverId,
+  dataRoot,
+  fetch,
+  testPushUrl ?? sandboxPushUrl
+);
 var allowedOrigins = [
   .../* @__PURE__ */ new Set([
     "agentrific-desktop://app",
@@ -4054,7 +4183,24 @@ app.get("/api/projects", async (_request, reply) => {
   const root = await Effect17.runPromise(store.projectsRoot(defaultProjectsRoot));
   const result = await Effect17.runPromise(discoverProjects(root, store).pipe(Effect17.result));
   if (result._tag === "Failure") return reply.code(400).send({ error: result.failure.message });
-  return result.success;
+  return Effect17.runPromise(
+    Effect17.forEach(
+      result.success,
+      (project) => Effect17.promise(async () => ({
+        ...project,
+        repository: project.available ? await readRepositoryIdentity(project.path) : null
+      })),
+      { concurrency: 4 }
+    )
+  );
+});
+app.get("/api/projects/:id/git-status", async (request, reply) => {
+  const root = await Effect17.runPromise(store.projectsRoot(defaultProjectsRoot));
+  const projects = await Effect17.runPromise(discoverProjects(root, store));
+  const project = projects.find((item) => item.id === request.params.id);
+  if (!project?.available)
+    return reply.code(404).send({ error: "Project folder unavailable on this server." });
+  return projectGitStatus(project.path);
 });
 app.get("/api/projects/:id", async (request, reply) => {
   const root = await Effect17.runPromise(store.projectsRoot(defaultProjectsRoot));
@@ -4078,39 +4224,51 @@ app.get(
   "/api/tasks",
   (request) => boardTasks(store, request.query.projectId)
 );
+app.get("/api/task-moves", () => ({ supported: true }));
 app.post("/api/tasks", async (request, reply) => {
   const parsed = CreateTaskSchema.safeParse(request.body);
   if (!parsed.success) return reply.code(400).send({ error: "Enter a task title." });
-  if (parsed.data.gitFlow?.delivery === "pull_request") {
-    const github = await githubCliStatus();
-    if (!github.githubCli.authenticated)
-      return reply.code(400).send({ error: "GitHub CLI must be authenticated on the server to open a PR." });
-  }
-  const projectsRoot = await Effect17.runPromise(store.projectsRoot(defaultProjectsRoot));
-  const projects = await Effect17.runPromise(
-    discoverProjects(projectsRoot, store).pipe(Effect17.result)
-  );
-  if (projects._tag === "Failure" || !projects.success.some((project) => project.id === parsed.data.projectId && project.available))
-    return reply.code(404).send({ error: "Project not found in the server's projects folder." });
-  let files;
-  try {
-    files = await Effect17.runPromise(
-      attachments.resolve(parsed.data.projectId, parsed.data.attachmentIds ?? [])
+  const save = async () => {
+    if (parsed.data.clientTaskId) {
+      const existing = await Effect17.runPromise(store.getTask(parsed.data.clientTaskId));
+      if (existing) {
+        if (existing.deletedAt || existing.projectId !== parsed.data.projectId || existing.title !== parsed.data.title || existing.prompt !== parsed.data.prompt || JSON.stringify(existing.gitFlow) !== JSON.stringify(parsed.data.gitFlow) || JSON.stringify(existing.model) !== JSON.stringify(parsed.data.model))
+          return reply.code(409).send({ error: "This task creation request has already been used." });
+        return reply.code(201).send(existing);
+      }
+    }
+    if (parsed.data.gitFlow?.delivery === "pull_request") {
+      const github = await githubCliStatus();
+      if (!github.githubCli.authenticated)
+        return reply.code(400).send({ error: "GitHub CLI must be authenticated on the server to open a PR." });
+    }
+    const projectsRoot = await Effect17.runPromise(store.projectsRoot(defaultProjectsRoot));
+    const projects = await Effect17.runPromise(
+      discoverProjects(projectsRoot, store).pipe(Effect17.result)
     );
-  } catch (error) {
-    return reply.code(400).send({ error: String(error) });
-  }
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const task = TaskSchema.parse({
-    id: randomUUID9(),
-    ...parsed.data,
-    attachments: files,
-    status: "backlog",
-    sessionId: null,
-    createdAt: now,
-    updatedAt: now
-  });
-  return reply.code(201).send(await Effect17.runPromise(store.saveTask(task)));
+    if (projects._tag === "Failure" || !projects.success.some((project) => project.id === parsed.data.projectId && project.available))
+      return reply.code(404).send({ error: "Project not found in the server's projects folder." });
+    let files;
+    try {
+      files = await Effect17.runPromise(
+        attachments.resolve(parsed.data.projectId, parsed.data.attachmentIds ?? [])
+      );
+    } catch (error) {
+      return reply.code(400).send({ error: String(error) });
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const task = TaskSchema.parse({
+      id: parsed.data.clientTaskId ?? randomUUID9(),
+      ...parsed.data,
+      attachments: files,
+      status: "backlog",
+      sessionId: null,
+      createdAt: now,
+      updatedAt: now
+    });
+    return reply.code(201).send(await Effect17.runPromise(store.saveTask(task)));
+  };
+  return parsed.data.clientTaskId ? withTaskLock(`create-task:${parsed.data.clientTaskId}`, save) : save();
 });
 app.patch("/api/tasks/:id", async (request, reply) => {
   const parsed = UpdateTaskSchema.safeParse(request.body);
@@ -4137,6 +4295,18 @@ app.patch("/api/tasks/:id", async (request, reply) => {
     throw error;
   }
 });
+app.post("/api/tasks/:id/discard-unrun", async (request, reply) => {
+  const parsed = z17.object({ updatedAt: z17.string().datetime() }).safeParse(request.body);
+  if (!parsed.success) return reply.code(400).send({ error: "The task revision is required." });
+  try {
+    await deleteTask(store, request.params.id, void 0, parsed.data.updatedAt);
+    return reply.code(204).send();
+  } catch (error) {
+    if (error instanceof TaskActionError)
+      return reply.code(error.status).send({ error: error.message });
+    throw error;
+  }
+});
 app.delete("/api/tasks/:id", async (request, reply) => {
   try {
     await deleteTask(store, request.params.id, async (session) => {