workplane 0.1.1

package/dist/node.js

@@ -0,0 +1,606 @@
+#!/usr/bin/env node
+
+// ../node/src/index.ts
+import { mkdir as mkdir2, writeFile as writeFile3 } from "fs/promises";
+import { join as join6, resolve } from "path";
+
+// ../core/src/config.ts
+import { z } from "zod";
+
+// ../core/src/env.ts
+import { config as dotenvConfig } from "dotenv";
+var envLoaded = false;
+function loadLocalEnv() {
+  if (envLoaded) {
+    return;
+  }
+  dotenvConfig({ path: ".env" });
+  dotenvConfig({ path: ".env.local", override: true });
+  envLoaded = true;
+}
+
+// ../core/src/config.ts
+loadLocalEnv();
+var serverEnvSchema = z.object({
+  DATABASE_URL: z.string().min(1),
+  WORKPLANE_SERVER_PORT: z.string().optional().default("8787").transform((value) => Number.parseInt(value, 10)),
+  WORKPLANE_NODE_TOKEN: z.string().optional(),
+  WORKPLANE_OPERATOR_TOKEN: z.string().optional(),
+  WORKPLANE_ENV_ALLOWLIST: z.string().optional()
+});
+var nodeEnvSchema = z.object({
+  WORKPLANE_SERVER_URL: z.string().url().optional().default("http://localhost:8787"),
+  WORKPLANE_NODE_NAME: z.string().optional().default("local-node-1"),
+  WORKPLANE_NODE_ID: z.string().optional(),
+  WORKPLANE_NODE_CAPABILITIES: z.string().optional().default("shell,git,node,typescript,aider,ollama,codex,claude-code"),
+  WORKPLANE_NODE_TOKEN: z.string().optional(),
+  WORKPLANE_POLL_INTERVAL_MS: z.string().optional().default("3000").transform((value) => Number.parseInt(value, 10)),
+  WORKPLANE_ENV_ALLOWLIST: z.string().optional()
+});
+function loadServerConfig(env = process.env) {
+  const parsed = serverEnvSchema.parse(env);
+  return {
+    databaseUrl: parsed.DATABASE_URL,
+    port: parsed.WORKPLANE_SERVER_PORT,
+    nodeToken: parsed.WORKPLANE_NODE_TOKEN,
+    operatorToken: parsed.WORKPLANE_OPERATOR_TOKEN,
+    envAllowlist: parseCsv(parsed.WORKPLANE_ENV_ALLOWLIST ?? "")
+  };
+}
+function loadNodeConfig(env = process.env) {
+  const parsed = nodeEnvSchema.parse(env);
+  return {
+    serverUrl: parsed.WORKPLANE_SERVER_URL,
+    nodeName: parsed.WORKPLANE_NODE_NAME,
+    nodeId: parsed.WORKPLANE_NODE_ID,
+    nodeCapabilities: parseCsv(parsed.WORKPLANE_NODE_CAPABILITIES),
+    nodeToken: parsed.WORKPLANE_NODE_TOKEN,
+    pollIntervalMs: parsed.WORKPLANE_POLL_INTERVAL_MS,
+    envAllowlist: parseCsv(parsed.WORKPLANE_ENV_ALLOWLIST ?? "")
+  };
+}
+function parseCsv(value) {
+  return value.split(",").map((entry) => entry.trim()).filter(Boolean);
+}
+
+// ../core/src/auth.ts
+function authHeaders(token) {
+  if (!token) {
+    return {};
+  }
+  return { authorization: `Bearer ${token}` };
+}
+
+// ../core/src/http-client.ts
+function buildWorkplaneHeaders(options = {}) {
+  const token = options.nodeToken ?? options.operatorToken;
+  return {
+    "content-type": "application/json",
+    ...authHeaders(token)
+  };
+}
+async function workplaneFetch(serverUrl, path, options = {}) {
+  const response = await fetch(`${serverUrl}${path}`, {
+    method: options.method ?? "GET",
+    headers: buildWorkplaneHeaders(options),
+    body: options.body ? JSON.stringify(options.body) : void 0
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`${response.status} ${response.statusText} from ${path}: ${text}`);
+  }
+  return await response.json();
+}
+
+// ../core/src/git.ts
+import { join } from "path";
+function repoPath(workspacePath) {
+  return join(workspacePath, "repo");
+}
+async function createTaskBranch(context, branchName) {
+  const cwd = repoPath(context.workspacePath);
+  await context.log("system", `creating branch ${branchName}`, "git-branch");
+  const checkout = await context.exec("git", ["checkout", "-b", branchName], { cwd });
+  if (checkout.exitCode !== 0) {
+    throw new Error(`git checkout -b failed with exit code ${checkout.exitCode}`);
+  }
+}
+function defaultTaskBranchName(runId) {
+  return `workplane/${runId}`;
+}
+async function captureGitDiff(context, adapterName, artifactName = "changes.diff") {
+  const cwd = repoPath(context.workspacePath);
+  const diffResult = await context.exec("git", ["diff"], { cwd });
+  const artifactsPath = await context.ensureWorkspace("artifacts");
+  const diffPath = join(artifactsPath, artifactName);
+  const { writeFile: writeFile4 } = await import("fs/promises");
+  await writeFile4(diffPath, diffResult.stdout, "utf8");
+  await context.emitArtifact({
+    type: "diff",
+    name: artifactName,
+    path: diffPath,
+    metadata: { adapter: adapterName }
+  });
+  return diffPath;
+}
+
+// ../adapter-sdk/src/index.ts
+import { spawn } from "child_process";
+import { mkdir } from "fs/promises";
+import { join as join2 } from "path";
+function pickEnv(allowlist) {
+  if (!allowlist || allowlist.length === 0) {
+    return { ...process.env };
+  }
+  const picked = {};
+  for (const key of allowlist) {
+    const value = process.env[key];
+    if (value !== void 0) {
+      picked[key] = value;
+    }
+  }
+  picked.PATH = process.env.PATH ?? "";
+  picked.HOME = process.env.HOME ?? "";
+  return picked;
+}
+function createCancellableExec(context) {
+  let activeChild;
+  const exec = async (command, args = [], options = {}) => new Promise((resolve2) => {
+    let childError;
+    const child = spawn(command, args, {
+      cwd: options.cwd ?? context.workspacePath,
+      env: {
+        ...pickEnv(context.envAllowlist),
+        ...options.env ?? {}
+      },
+      signal: options.signal
+    });
+    activeChild = child;
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      const text = chunk.toString();
+      stdout += text;
+      void context.log("stdout", text);
+    });
+    child.stderr.on("data", (chunk) => {
+      const text = chunk.toString();
+      stderr += text;
+      void context.log("stderr", text);
+    });
+    child.on("error", (error) => {
+      childError = error;
+    });
+    child.on("close", (exitCode, signal) => {
+      if (activeChild === child) {
+        activeChild = void 0;
+      }
+      if (signal === "SIGTERM" || signal === "SIGKILL") {
+        resolve2({
+          exitCode: exitCode ?? 1,
+          stdout,
+          stderr: `${stderr}
+process terminated (${signal})`.trim()
+        });
+        return;
+      }
+      resolve2({
+        exitCode: exitCode ?? 1,
+        stdout,
+        stderr: childError ? `${stderr}
+${childError.message}`.trim() : stderr
+      });
+    });
+  });
+  const kill = () => {
+    if (activeChild && !activeChild.killed) {
+      activeChild.kill("SIGTERM");
+    }
+  };
+  return { exec, kill };
+}
+async function ensureWorkspacePath(workspacePath, ...segments) {
+  const fullPath = join2(workspacePath, ...segments);
+  await mkdir(fullPath, { recursive: true });
+  return fullPath;
+}
+
+// ../adapter-shell/src/index.ts
+import { join as join3 } from "path";
+import { writeFile } from "fs/promises";
+var shellAdapter = {
+  name: "shell",
+  kind: "shell.exec",
+  async run(context, payload) {
+    const renderedCommand = payload.args && payload.args.length > 0 ? `${payload.command} ${payload.args.join(" ")}` : payload.command;
+    const commandCwd = payload.cwd ? payload.cwd.startsWith("/") ? payload.cwd : join3(context.workspacePath, payload.cwd) : context.workspacePath;
+    const result = await context.exec("/bin/sh", ["-lc", renderedCommand], { cwd: commandCwd });
+    const artifactsDir = await context.ensureWorkspace("artifacts");
+    const resultPath = join3(artifactsDir, "shell-result.json");
+    await writeFile(
+      resultPath,
+      JSON.stringify(
+        {
+          command: renderedCommand,
+          cwd: commandCwd,
+          exitCode: result.exitCode
+        },
+        null,
+        2
+      ),
+      "utf8"
+    );
+    await context.emitArtifact({
+      type: "shell.result",
+      name: "shell-result.json",
+      path: resultPath,
+      metadata: { exitCode: result.exitCode }
+    });
+    if (result.exitCode !== 0) {
+      throw new Error(`shell command failed with exit code ${result.exitCode}`);
+    }
+  }
+};
+
+// ../adapter-aider/src/index.ts
+var aiderAdapter = {
+  name: "aider",
+  kind: "agent.run",
+  async run(context, payload) {
+    const cwd = repoPath(context.workspacePath);
+    await createTaskBranch(context, defaultTaskBranchName(context.runId));
+    const args = ["--yes", "--message", payload.prompt];
+    if (payload.model) {
+      args.unshift("--model", payload.model);
+    }
+    const result = await context.exec("aider", args, { cwd });
+    if (result.exitCode !== 0) {
+      throw new Error(`aider failed with exit code ${result.exitCode}`);
+    }
+    await captureGitDiff(context, "aider");
+    if (payload.testCommand) {
+      await context.log("system", `running test command: ${payload.testCommand}`, "run-tests");
+      const testResult = await context.exec("/bin/sh", ["-lc", payload.testCommand], { cwd });
+      if (testResult.exitCode !== 0) {
+        throw new Error(`test command failed with exit code ${testResult.exitCode}`);
+      }
+    }
+  }
+};
+
+// ../adapter-ollama/src/index.ts
+import { writeFile as writeFile2 } from "fs/promises";
+import { join as join4 } from "path";
+var ollamaAdapter = {
+  name: "ollama",
+  kind: "inference.batch",
+  async run(context, payload) {
+    const args = ["run", payload.model, payload.prompt];
+    const result = await context.exec("ollama", args, { cwd: context.workspacePath });
+    if (result.exitCode !== 0) {
+      throw new Error(`ollama failed with exit code ${result.exitCode}`);
+    }
+    const artifactsPath = await context.ensureWorkspace("artifacts");
+    const outputPath = join4(artifactsPath, "inference-output.txt");
+    const output = `${result.stdout}${result.stderr}`.trim();
+    await writeFile2(outputPath, output, "utf8");
+    await context.emitArtifact({
+      type: "inference.output",
+      name: "inference-output.txt",
+      path: outputPath,
+      metadata: { model: payload.model, adapter: "ollama" }
+    });
+    if (payload.inputFile) {
+      await context.log("system", `inputFile ${payload.inputFile} noted (batch file expansion not implemented)`, "inference");
+    }
+  }
+};
+
+// ../adapter-harness/src/index.ts
+import { join as join5 } from "path";
+function resolveBinary(binary) {
+  return typeof binary === "function" ? binary() : binary;
+}
+function createHarnessAdapter(options) {
+  return {
+    name: options.name,
+    kind: options.kind,
+    async run(context, payload) {
+      const cwd = repoPath(context.workspacePath);
+      const branchName = payload.taskBranch ?? defaultTaskBranchName(context.runId);
+      await createTaskBranch(context, branchName);
+      const extra = payload.extraArgs ?? options.defaultArgs ?? [];
+      const promptArgs = options.buildArgs ? options.buildArgs(payload) : [...extra, payload.prompt];
+      const binary = resolveBinary(options.binary);
+      const result = await context.exec(binary, promptArgs, { cwd });
+      if (result.exitCode !== 0) {
+        throw new Error(`${binary} failed with exit code ${result.exitCode}`);
+      }
+      await captureGitDiff(context, options.name);
+      if (payload.testCommand) {
+        await context.log("system", `running test command: ${payload.testCommand}`, "run-tests");
+        const testResult = await context.exec("/bin/sh", ["-lc", payload.testCommand], { cwd });
+        const testArtifactPath = join5(await context.ensureWorkspace("artifacts"), "test-output.txt");
+        const { writeFile: writeFile4 } = await import("fs/promises");
+        await writeFile4(testArtifactPath, `${testResult.stdout}
+${testResult.stderr}`, "utf8");
+        await context.emitArtifact({
+          type: "test.output",
+          name: "test-output.txt",
+          path: testArtifactPath,
+          metadata: { exitCode: testResult.exitCode }
+        });
+        if (testResult.exitCode !== 0) {
+          throw new Error(`test command failed with exit code ${testResult.exitCode}`);
+        }
+      }
+    }
+  };
+}
+
+// ../adapter-codex/src/index.ts
+var codexAdapter = createHarnessAdapter({
+  name: "codex",
+  kind: "agent.run",
+  binary: () => process.env.WORKPLANE_CODEX_BIN ?? "codex",
+  defaultArgs: ["--approval-mode", "full-auto"],
+  buildArgs: (payload) => {
+    const args = [...payload.extraArgs ?? ["--approval-mode", "full-auto"]];
+    if (payload.model) {
+      args.push("--model", payload.model);
+    }
+    args.push(payload.prompt);
+    return args;
+  }
+});
+
+// ../adapter-claude-code/src/index.ts
+var claudeCodeAdapter = createHarnessAdapter({
+  name: "claude-code",
+  kind: "agent.run",
+  binary: () => process.env.WORKPLANE_CLAUDE_CODE_BIN ?? "claude",
+  buildArgs: (payload) => {
+    const args = ["-p", payload.prompt, "--output-format", "text"];
+    if (payload.model) {
+      args.push("--model", payload.model);
+    }
+    const extra = payload.extraArgs ?? [];
+    return [...args, ...extra];
+  }
+});
+
+// ../node/src/index.ts
+var REPO_ADAPTERS = /* @__PURE__ */ new Set(["aider", "codex", "claude-code"]);
+var adapters = /* @__PURE__ */ new Map([
+  ["shell", shellAdapter],
+  ["aider", aiderAdapter],
+  ["ollama", ollamaAdapter],
+  ["codex", codexAdapter],
+  ["claude-code", claudeCodeAdapter]
+]);
+function nowStamp() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+}
+function workspaceRoot() {
+  return resolve(process.env.WORKPLANE_WORKSPACE_ROOT ?? ".workplane/workspaces");
+}
+function shouldMirrorNodeLogs() {
+  const value = process.env.WORKPLANE_NODE_LOG_MIRROR;
+  if (!value) {
+    return false;
+  }
+  return value === "1" || value.toLowerCase() === "true" || value.toLowerCase() === "yes";
+}
+function stringPayloadValue(payload, key) {
+  const value = payload[key];
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function nodeHttpOptions(config) {
+  return { nodeToken: config.nodeToken };
+}
+async function updateStatus(config, runId, status, error) {
+  await workplaneFetch(config.serverUrl, `/runs/${runId}/status`, {
+    method: "POST",
+    body: { status, error },
+    ...nodeHttpOptions(config)
+  });
+}
+async function appendLogs(config, runId, logs) {
+  await workplaneFetch(config.serverUrl, `/runs/${runId}/logs`, {
+    method: "POST",
+    body: { logs },
+    ...nodeHttpOptions(config)
+  });
+}
+async function emitArtifact(config, runId, artifact) {
+  await workplaneFetch(config.serverUrl, `/runs/${runId}/artifacts`, {
+    method: "POST",
+    body: artifact,
+    ...nodeHttpOptions(config)
+  });
+}
+async function isCancelled(config, runId) {
+  const run = await workplaneFetch(config.serverUrl, `/runs/${runId}`, nodeHttpOptions(config));
+  if (run.status === "cancelled") {
+    return true;
+  }
+  const task = await workplaneFetch(
+    config.serverUrl,
+    `/tasks/${run.taskId}`,
+    nodeHttpOptions(config)
+  );
+  return task.status === "cancelled";
+}
+async function checkoutRepoIfPresent(context, payload) {
+  const repo = stringPayloadValue(payload, "repo");
+  if (!repo) {
+    return false;
+  }
+  await context.log("system", `cloning repository ${repo}`, "checkout-repo");
+  const cloneResult = await context.exec("git", ["clone", repo, "repo"], {
+    cwd: context.workspacePath
+  });
+  if (cloneResult.exitCode !== 0) {
+    throw new Error(`git clone failed with exit code ${cloneResult.exitCode}`);
+  }
+  const branch = stringPayloadValue(payload, "branch");
+  if (branch) {
+    await context.log("system", `checking out branch ${branch}`, "checkout-repo");
+    const checkoutResult = await context.exec("git", ["checkout", branch], {
+      cwd: repoPath(context.workspacePath)
+    });
+    if (checkoutResult.exitCode !== 0) {
+      throw new Error(`git checkout failed with exit code ${checkoutResult.exitCode}`);
+    }
+  }
+  await context.emitArtifact({
+    type: "workspace.repo",
+    name: "repo-checkout",
+    path: repoPath(context.workspacePath),
+    metadata: { repo, branch: branch ?? null }
+  });
+  return true;
+}
+async function executeAssignment(config, assignment) {
+  const runId = assignment.run.id;
+  const task = assignment.task;
+  const adapter = adapters.get(task.adapter);
+  if (!adapter) {
+    await updateStatus(config, runId, "failed", `adapter not registered: ${task.adapter}`);
+    return;
+  }
+  const runWorkspace = join6(workspaceRoot(), `${runId}_${nowStamp()}`);
+  const mirrorLogs = shouldMirrorNodeLogs();
+  await mkdir2(runWorkspace, { recursive: true });
+  await ensureWorkspacePath(runWorkspace, "logs");
+  await ensureWorkspacePath(runWorkspace, "artifacts");
+  await ensureWorkspacePath(runWorkspace, "tmp");
+  await writeFile3(
+    join6(runWorkspace, "metadata.json"),
+    JSON.stringify({ runId, taskId: task.id, adapter: task.adapter, createdAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2),
+    "utf8"
+  );
+  await updateStatus(config, runId, "running");
+  const serverEnvAllowlist = config.envAllowlist.length > 0 ? config.envAllowlist : loadServerConfig().envAllowlist.length > 0 ? loadServerConfig().envAllowlist : void 0;
+  const { exec, kill } = createCancellableExec({
+    runId,
+    taskId: task.id,
+    workspacePath: runWorkspace,
+    log: async () => {
+    },
+    exec: async () => ({ exitCode: 1, stdout: "", stderr: "not initialized" }),
+    ensureWorkspace: async (...segments) => ensureWorkspacePath(runWorkspace, ...segments),
+    emitArtifact: async () => {
+    },
+    envAllowlist: serverEnvAllowlist
+  });
+  const context = {
+    runId,
+    taskId: task.id,
+    workspacePath: runWorkspace,
+    envAllowlist: serverEnvAllowlist,
+    log: async (stream, message, stepName) => {
+      if (mirrorLogs) {
+        const prefix = `[run:${runId}] [${stream}]${stepName ? ` [${stepName}]` : ""} `;
+        if (stream === "stderr") {
+          process.stderr.write(`${prefix}${message}`);
+        } else {
+          process.stdout.write(`${prefix}${message}`);
+        }
+      }
+      await appendLogs(config, runId, [{ stream, message, stepName }]);
+    },
+    exec,
+    ensureWorkspace: async (...segments) => ensureWorkspacePath(runWorkspace, ...segments),
+    emitArtifact: async (input) => {
+      await emitArtifact(config, runId, input);
+    }
+  };
+  const cancelInterval = setInterval(() => {
+    void isCancelled(config, runId).then((cancelled) => {
+      if (cancelled) {
+        kill();
+      }
+    });
+  }, 2e3);
+  try {
+    await context.log("system", `starting adapter ${adapter.name}`, "run-adapter");
+    const hasRepo = await checkoutRepoIfPresent(context, task.payload);
+    if (REPO_ADAPTERS.has(adapter.name) && !hasRepo) {
+      throw new Error(`${adapter.name} adapter requires payload.repo`);
+    }
+    const adapterPayload = { ...task.payload };
+    if (adapter.name === "shell" && hasRepo && typeof adapterPayload.cwd !== "string") {
+      adapterPayload.cwd = "repo";
+    }
+    if (REPO_ADAPTERS.has(adapter.name) && adapter.name !== "aider" && !stringPayloadValue(adapterPayload, "taskBranch")) {
+      adapterPayload.taskBranch = defaultTaskBranchName(runId);
+    }
+    await adapter.run(context, adapterPayload);
+    if (await isCancelled(config, runId)) {
+      await context.log("system", "run cancelled", "run-adapter");
+      await updateStatus(config, runId, "cancelled", "task cancelled");
+      return;
+    }
+    await context.log("system", "adapter execution finished", "run-adapter");
+    await updateStatus(config, runId, "succeeded");
+  } catch (error) {
+    if (await isCancelled(config, runId)) {
+      await updateStatus(config, runId, "cancelled", "task cancelled");
+      return;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    await context.log("stderr", message, "run-adapter");
+    await updateStatus(config, runId, "failed", message);
+  } finally {
+    clearInterval(cancelInterval);
+    kill();
+  }
+}
+async function main() {
+  const config = loadNodeConfig();
+  const register = await workplaneFetch(config.serverUrl, "/nodes/register", {
+    method: "POST",
+    body: {
+      name: config.nodeName,
+      capabilities: config.nodeCapabilities,
+      nodeId: config.nodeId
+    },
+    ...nodeHttpOptions(config)
+  });
+  const nodeId = register.id;
+  process.stdout.write(`node registered: ${nodeId}
+`);
+  while (true) {
+    try {
+      const poll = await workplaneFetch(
+        config.serverUrl,
+        `/nodes/${nodeId}/poll`,
+        {
+          method: "POST",
+          body: {
+            capabilities: config.nodeCapabilities
+          },
+          ...nodeHttpOptions(config)
+        }
+      );
+      if (poll.assignment) {
+        await executeAssignment(config, poll.assignment);
+      }
+    } catch (error) {
+      process.stderr.write(`poll error: ${String(error)}
+`);
+    }
+    await new Promise((resolvePromise) => setTimeout(resolvePromise, config.pollIntervalMs));
+  }
+}
+main().catch((error) => {
+  process.stderr.write(`${String(error)}
+`);
+  process.exit(1);
+});
+//# sourceMappingURL=node.js.map