drafted 1.25.5 → 1.25.7

package/cli/drafted.mjs

@@ -19,6 +19,7 @@ import { DESIGN_SYSTEM_PROMPT, buildDesignPrompt } from './prompts.mjs';
 import { scanRepoAgents, detectDefaultBranch, detectRemoteUrl, isGitUrl, cloneToTemp, classifySeed } from './repo-scan.mjs';
 import { setupTrusted } from './skill-setup-trust.mjs';
 import { openCommandFor } from './open-url.mjs';
+import { actionState } from '../src/shared/action-state.mjs';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -2250,16 +2251,6 @@ async function minionSetEnabled(id, enabled, format) {
 // Approving stays a browser-only act in Drafted; nothing here can approve.
 const actionCmd = program.command('action').description('Propose an outward effect for a person to approve, and read its decision');
 
-function actionState(actions) {
-  const st = (actions || []).map((a) => a.status);
-  if (!st.length) return 'unknown';
-  if (st.every((s) => s === 'proposed')) return 'waiting';
-  if (st.includes('rejected')) return 'rejected';
-  if (st.includes('failed')) return 'failed';
-  if (st.every((s) => s === 'executed')) return 'executed';
-  return 'approved';
-}
-
 async function actionApi(method, apiPath, org, body) {
   requireLogin();
   const server = getServerUrl().replace(/\/$/, '');
@@ -2317,6 +2308,72 @@ actionCmd
     else console.log(`${out.state}\t${out.decidedBy || ''}\t${out.note || ''}`);
   });
 
+const flowToolsCmd = program.command('flow-tools').description('Read-only tools for an agent@1 flow step run outside Drafted (served by the drafted-flow-tools MCP server)');
+
+flowToolsCmd
+  .command('token')
+  .description('Mint a run-scoped, read-only token for drafted-flow-tools: one project, the listed tools, expiring (default 60, at most 240 minutes). Prints the token once.')
+  .requiredOption('--project <id>', 'project (id) the step runs in')
+  .requiredOption('--tools <names>', 'comma-separated tools from the read-only toolset, e.g. search_wiki,read_frame')
+  .option('--ttl <minutes>', 'minutes until it expires')
+  .option('--format <fmt>', 'output format: json or text', 'text')
+  .action(async (opts) => {
+    const tools = String(opts.tools).split(',').map((t) => t.trim()).filter(Boolean);
+    const r = await actionApi('POST', '/api/flow-tools/tokens', null, { projectId: opts.project, tools, ttlMinutes: opts.ttl ? Number(opts.ttl) : undefined });
+    if (!r.ok) {
+      const out = { status: 'error', error: r.data.error || `HTTP ${r.status}` };
+      if (opts.format === 'json') console.log(JSON.stringify(out)); else console.error(`error\t${out.error}`);
+      process.exit(1);
+    }
+    if (opts.format === 'json') console.log(JSON.stringify({ status: 'ok', token: r.data.token, expiresAt: r.data.expiresAt, tools: r.data.tools }));
+    else console.log(r.data.token);
+  });
+
+// ── Automations: start a skill flow in Drafted ──────────────────────────
+// The "local agent" trigger (U2): the same run as the Flows tab's Run now, at the
+// published version, as you. The request returns once the run finishes or parks
+// on an approval, so the status printed is where it stands, not "started".
+const automationCmd = program.command('automation').description('Run a skill\'s flows in Drafted');
+
+automationCmd
+  .command('run <skill> [flow]')
+  .description('Run a flow (default: "default") of an org skill at its published version. --input becomes the run\'s untrusted trigger.json input.')
+  .option('--project <id>', 'project the run happens in (defaults to your active project)')
+  .option('--input <text>', 'input text for the run')
+  .option('--input-file <path>', 'read the input from a file ("-" for stdin)')
+  .option('--org <org>', 'org (id or slug) the skill belongs to')
+  .option('--format <fmt>', 'output format: json or text', 'text')
+  .action(async (skillSlug, flow, opts) => {
+    const fail = (error) => {
+      if (opts.format === 'json') console.log(JSON.stringify({ status: 'error', error }));
+      else console.error(`error\t${error}`);
+      process.exit(1);
+    };
+    const projectId = opts.project || getActiveProject()?.id;
+    if (!projectId) fail('no project: pass --project or run `drafted use-project <id>` first');
+    let input = opts.input;
+    if (opts.inputFile) {
+      try { input = readFileSync(opts.inputFile === '-' ? 0 : opts.inputFile, 'utf8'); } catch (err) { fail(`cannot read ${opts.inputFile}: ${err.message}`); }
+    }
+    const chain = flow || 'default';
+    const found = await actionApi('GET', `/api/skills/slug/${encodeURIComponent(skillSlug)}?lookup=1`, opts.org);
+    if (!found.ok) fail(found.data.error || `HTTP ${found.status}`);
+    const skillId = found.data.id;
+    const run = await actionApi('POST', `/api/skills/${encodeURIComponent(skillId)}/flows/${encodeURIComponent(chain)}/run`, opts.org, { projectId, input: input ?? '' });
+    if (!run.ok) fail(run.data.error || `HTTP ${run.status}`);
+    const list = await actionApi('GET', `/api/skills/${encodeURIComponent(skillId)}/automation-runs`, opts.org);
+    const r = (list.ok && (list.data.runs || []).find((x) => x.id === run.data.runId)) || {};
+    const out = {
+      status: 'ok', runId: run.data.runId, version: run.data.version, flow: chain,
+      state: r.status || 'unknown', error: r.error || null,
+      steps: (r.steps || []).map((st) => ({ id: st.id, status: st.status, actionGroupId: st.actionGroupId || null })),
+    };
+    if (opts.format === 'json') { console.log(JSON.stringify(out)); return; }
+    console.log(`${out.runId}\t${out.state}\tv${out.version}${out.error ? `\t${out.error}` : ''}`);
+    for (const st of out.steps) console.log(`  ${st.id}\t${st.status}${st.actionGroupId ? `\t${st.actionGroupId}` : ''}`);
+    if (out.state === 'failed') process.exit(1);
+  });
+
 const minionCmd = program.command('minion').description('Minion management (checklist-driven intake surfaces). Requires the agent allowlist.');
 
 minionCmd

package/mcp/flow-tools.mjs

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+/**
+ * drafted-flow-tools: the stdio MCP server an agent@1 step runs against when it
+ * runs OUTSIDE Drafted (a Causeway backend). It serves exactly two kinds of tool:
+ *
+ *   - the step's read-only tools, listed and executed by Drafted itself
+ *     (GET/POST /api/flow-tools, server/lib/flow-tools-routes.mjs) — the same
+ *     code Drafted's own runner calls, so "search_wiki" means one thing;
+ *   - submit_output, whose parameters ARE the author's output schema. An answer
+ *     is checked with src/shared/agent-output.mjs (the same check Drafted's
+ *     runner uses) and, when it fits, written to the step's output file.
+ *
+ * Configuration (environment):
+ *   DRAFTED_FLOW_TOKEN   a run-scoped token from POST /api/flow-tools/tokens
+ *   DRAFTED_URL          Drafted's base URL (default https://drafted.live)
+ *   FLOW_OUTPUT_SCHEMA   path to the step's output schema (JSON)
+ *   FLOW_OUTPUT_FILE     where an accepted answer is written (JSON)
+ *
+ * It holds no other credential and offers no other tool: a backend pointed at
+ * this server and nothing else can read what the token allows, and answer.
+ */
+import { readFileSync, writeFileSync } from 'node:fs';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { outputErrors } from '../src/shared/agent-output.mjs';
+
+const SUBMIT = 'submit_output';
+
+function config(env = process.env) {
+  const missing = ['DRAFTED_FLOW_TOKEN', 'FLOW_OUTPUT_SCHEMA', 'FLOW_OUTPUT_FILE'].filter((k) => !env[k]);
+  if (missing.length) throw new Error(`drafted-flow-tools: set ${missing.join(', ')}`);
+  return {
+    token: env.DRAFTED_FLOW_TOKEN,
+    base: (env.DRAFTED_URL || 'https://drafted.live').replace(/\/+$/, ''),
+    schema: JSON.parse(readFileSync(env.FLOW_OUTPUT_SCHEMA, 'utf8')),
+    outputFile: env.FLOW_OUTPUT_FILE,
+  };
+}
+
+async function drafted(cfg, method, path, body) {
+  const res = await fetch(cfg.base + '/api/flow-tools' + path, {
+    method,
+    headers: { 'content-type': 'application/json', 'x-drafted-flow-token': cfg.token },
+    body: body === undefined ? undefined : JSON.stringify(body),
+  });
+  const json = await res.json().catch(() => ({}));
+  if (!res.ok) throw new Error(json.error || `Drafted answered ${res.status}`);
+  return json;
+}
+
+async function main() {
+  const cfg = config();
+  const { tools } = await drafted(cfg, 'GET', '/tools');
+  const names = new Set(tools.map((t) => t.name));
+  let accepted = false;
+  const server = new Server({ name: 'drafted-flow-tools', version: '1' }, { capabilities: { tools: {} } });
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+      ...tools.map((t) => ({ name: t.name, description: t.description, inputSchema: t.parameters })),
+      { name: SUBMIT, description: 'Submit your final answer. Call it once, with arguments matching this schema exactly.', inputSchema: cfg.schema },
+    ],
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    const { name, arguments: args = {} } = req.params;
+    const text = (value) => ({ content: [{ type: 'text', text: typeof value === 'string' ? value : JSON.stringify(value) }] });
+    if (name === SUBMIT) {
+      if (accepted) return { ...text('An answer was already accepted for this step.'), isError: true };
+      const errors = outputErrors(cfg.schema, args);
+      if (errors.length) return { ...text(`Not accepted: ${errors.slice(0, 5).join('; ')}. Fix it and call submit_output again.`), isError: true };
+      writeFileSync(cfg.outputFile, JSON.stringify(args));
+      accepted = true;
+      return text('Accepted.');
+    }
+    if (!names.has(name)) return { ...text(`Tool not available: ${name}`), isError: true };
+    try {
+      return text(await drafted(cfg, 'POST', '/call', { name, args }));
+    } catch (err) {
+      return { ...text(`Error: ${err.message}`), isError: true };
+    }
+  });
+  await server.connect(new StdioServerTransport());
+}
+
+main().catch((err) => {
+  console.error(err.message || err);
+  process.exit(1);
+});

package/mcp/server.mjs

@@ -2830,7 +2830,7 @@ tool('trigger', {
   executor: z.enum(['queue', 'automation']).optional().describe('[create|update] who runs deliveries: "queue" (default) parks deliveries for a LOCAL agent to poll via pending/claim/complete — this is the Minion hand-off case and what a schedule would use; "automation" runs a skill\'s chain (automationSkill) at a pinned version in Drafted for each delivery, payload as the untrusted input trigger.json — only an org OWNER can create one or move its pin, and the chain must use built-ins Drafted runs (template@1, approval@1, when:). There is no webhook executor: the public ingress was retired on 2026-10-25.'),
   automationSkill: z.string().optional().describe('[create|update, executor=automation] the skill whose chain runs: its slug or id, in the project\'s org.'),
   automationChain: z.string().optional().describe('[create|update, executor=automation] which named chain (default "default").'),
-  automationSkillVersion: z.number().optional().describe('[create|update, executor=automation] the pinned skill version to run (default: the skill\'s current version). Moving the pin is publishing: owner only.'),
+  automationSkillVersion: z.number().optional().describe('[create|update, executor=automation] the skill version to run (default: the skill\'s published version, else its current one). One version runs for every automation of a skill, so pinning one publishes it and moves the skill\'s other automation triggers too: owner only.'),
   deliveryId: z.string().optional().describe('[complete] delivery ID returned by claim'),
   ok: z.boolean().optional().describe('[complete] whether the claimed work succeeded (default true)'),
   error: z.string().optional().describe('[complete] error note when ok=false'),

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "drafted",
-  "version": "1.25.5",
+  "version": "1.25.7",
   "description": "Drafted — visual thinking surface for humans and AI agents. Renders HTML, markdown, images, and code as frames on a zoomable canvas, with MCP tools for AI agents and real-time sync for humans.",
   "type": "module",
   "bin": {
     "drafted": "cli/drafted.mjs",
-    "drafted-mcp": "mcp/server.mjs"
+    "drafted-mcp": "mcp/server.mjs",
+    "drafted-flow-tools": "mcp/flow-tools.mjs"
   },
   "files": [
     "cli/",

package/src/shared/action-state.mjs

@@ -0,0 +1,15 @@
+/**
+ * The state of a proposed action group, from its actions' statuses: what an
+ * approval@1 step decides on. One implementation for every runner: Drafted's
+ * automation runner and the `drafted action status` command Causeway's
+ * approval@1 shim calls both import it (chain-spec/semantics.json holds the cases).
+ */
+export function actionState(actions) {
+  const st = (actions || []).map((a) => a.status);
+  if (!st.length) return 'unknown';
+  if (st.every((s) => s === 'proposed')) return 'waiting';
+  if (st.includes('rejected')) return 'rejected';
+  if (st.includes('failed')) return 'failed';
+  if (st.every((s) => s === 'executed')) return 'executed';
+  return 'approved';
+}

package/src/shared/agent-output.mjs

@@ -0,0 +1,29 @@
+/**
+ * Check an agent step's answer against the output schema its author wrote
+ * (the chain contract's subset: type, properties, required, items, enum,
+ * additionalProperties: false). One implementation for every runner: Drafted's
+ * in-process agent step and the drafted-flow-tools MCP server a Causeway
+ * backend calls both import it, so an answer accepted in one is accepted in the
+ * other. Returns a list of problems, empty when the answer fits.
+ */
+export function outputErrors(schema, value, at = 'output') {
+  const t = schema.type;
+  const ok = t === 'integer' ? Number.isInteger(value)
+    : t === 'number' ? typeof value === 'number' && Number.isFinite(value)
+    : t === 'array' ? Array.isArray(value)
+    : t === 'object' ? !!value && typeof value === 'object' && !Array.isArray(value)
+    : typeof value === t;
+  if (!ok) return [`${at} must be ${t}`];
+  if (schema.enum && !schema.enum.some((e) => e === value)) return [`${at} must be one of ${schema.enum.map((e) => JSON.stringify(e)).join(', ')}`];
+  const errs = [];
+  if (t === 'object') {
+    const props = schema.properties || {};
+    for (const r of schema.required || []) if (value[r] === undefined) errs.push(`${at}.${r} is required`);
+    for (const [k, v] of Object.entries(value)) {
+      if (props[k]) errs.push(...outputErrors(props[k], v, `${at}.${k}`));
+      else if (schema.additionalProperties === false) errs.push(`${at}.${k} is not allowed`);
+    }
+  }
+  if (t === 'array') value.forEach((v, i) => errs.push(...outputErrors(schema.items, v, `${at}[${i}]`)));
+  return errs;
+}