@ansible-flow/node 0.0.0-stage → 0.86.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sergei Chistokhin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,10 @@
-# Temporary Holding Version
+# @ansible-flow/node
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Ansible Flow Designer for Node hosts: layout, the probe client, runs, the AWX client, the module catalog and SSH.
+
+Built from [Ansible Flow Designer](https://github.com/ChistokhinSV/ansible-flow-designer) 0.86.0
+and released with it. Modules are imported by their path in the source tree, for example
+`@ansible-flow/node/ai/agents`.
+
+What is in the package, which entry points are documented and what may change:
+[docs/packages.md](https://github.com/ChistokhinSV/ansible-flow-designer/blob/main/docs/packages.md).

package/dist/ai/agents.d.ts

@@ -0,0 +1,34 @@
+import { type Agent, type Launch } from './writers';
+export interface AgentInfo {
+    id: Agent;
+    label: string;
+    /** Where the skill and the tools go, for the pick list. */
+    detail: string;
+    bins: string[];
+    /** Paths under the home folder that only this agent creates. */
+    markers: string[];
+    /** Installed apps: under %LOCALAPPDATA% on Windows, absolute on macOS. */
+    apps: {
+        win?: string;
+        mac?: string;
+    };
+    /** VS Code extension IDs (lowercase). */
+    extensions: string[];
+}
+export declare const AGENT_INFO: AgentInfo[];
+export declare const agentLabel: (id: Agent) => string;
+export interface Probe {
+    home: string;
+    /** %LOCALAPPDATA% on Windows. */
+    localAppData?: string;
+    platform: NodeJS.Platform;
+    onPath(name: string): Promise<string | undefined>;
+    /** Installed VS Code extension IDs, lowercase. */
+    extensions: string[];
+}
+/** The known agents on this machine, each with why it was found. */
+export declare function findAgents(probe: Probe): Promise<Map<Agent, string>>;
+/** The MCP entry most agents take (an "mcpServers" object). */
+export declare function mcpJson(launch: Launch): string;
+/** A guide for agents setup does not know: where the skill and the tools go, with this machine's command. */
+export declare function otherAgentGuide(launch: Launch): string;

package/dist/ai/agents.js

@@ -0,0 +1,16 @@
+import {
+  AGENT_INFO,
+  agentLabel,
+  findAgents,
+  mcpJson,
+  otherAgentGuide
+} from "../chunks/chunk-EPJKJBNW.js";
+import "../chunks/chunk-2MZQHIXP.js";
+export {
+  AGENT_INFO,
+  agentLabel,
+  findAgents,
+  mcpJson,
+  otherAgentGuide
+};
+//# sourceMappingURL=agents.js.map

package/dist/ai/agents.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/ai/hostConfig.d.ts

@@ -0,0 +1,44 @@
+import { type HostEnv, type HostId } from './hosts';
+import { type Env, type Registration } from './writers';
+/** AFD-195: the mcp.js our entry starts, and whether it is there. */
+export interface ServerFile {
+    path: string;
+    exists: boolean;
+}
+export interface McpFileState {
+    path: string;
+    exists: boolean;
+    /** Server names in it (mcpServers or servers). */
+    servers: string[];
+    /** Not JSON (with comments) the agent could read. */
+    broken?: boolean;
+    /** What our entry starts, when it starts an mcp.js. */
+    ours?: ServerFile;
+}
+export interface FolderState {
+    path: string;
+    exists: boolean;
+    /** Entries in it: skill or plugin folder names. */
+    entries: string[];
+}
+export interface HostConfig {
+    host: HostId;
+    mcp: McpFileState[];
+    skills: FolderState[];
+    plugins?: FolderState;
+}
+/** Each fork's MCP files, skill folders and plugin folder as they are now. */
+export declare function hostConfigs(env: HostEnv, hosts?: HostId[]): Promise<HostConfig[]>;
+/**
+ * Markdown lines for one editor's configuration; ours is marked, with the server file it starts.
+ * `server`: this extension's installed copy, to tell another extension ID's copy.
+ */
+export declare function configLines(c: HostConfig, server?: string): string[];
+/** AFD-195: each agent's ansible-flow entry as Set Up AI Assistants wrote it, and what it starts. */
+export declare function agentRegistrations(env: Env): Promise<{
+    registration: Registration | undefined;
+    file?: ServerFile;
+    agent: string;
+}[]>;
+/** Markdown lines for agentRegistrations; `server` is this extension's installed copy. */
+export declare function registrationLines(found: Awaited<ReturnType<typeof agentRegistrations>>, server: string): string[];

package/dist/ai/hostConfig.js

@@ -0,0 +1,120 @@
+import {
+  agentLabel
+} from "../chunks/chunk-EPJKJBNW.js";
+import {
+  HOSTS
+} from "../chunks/chunk-UNCR5JOZ.js";
+import {
+  AGENTS,
+  SERVER_NAME,
+  SKILL_NAME,
+  entryServer,
+  registration,
+  storageId
+} from "../chunks/chunk-2MZQHIXP.js";
+
+// src/node/ai/hostConfig.ts
+import { promises as fs } from "node:fs";
+import { parse } from "jsonc-parser";
+var fileExists = (path) => fs.stat(path).then(
+  () => true,
+  () => false
+);
+async function serverFile(server) {
+  return server ? { path: server, exists: await fileExists(server) } : void 0;
+}
+async function mcpFile(path) {
+  let text;
+  try {
+    text = await fs.readFile(path, "utf8");
+  } catch {
+    return { path, exists: false, servers: [] };
+  }
+  if (!text.trim()) return { path, exists: true, servers: [] };
+  const errors = [];
+  const data = parse(text, errors, { allowTrailingComma: true });
+  if (errors.length > 0 || !data || typeof data !== "object")
+    return { path, exists: true, servers: [], broken: true };
+  const table = data.mcpServers ?? data.servers;
+  const ours = await serverFile(entryServer(table?.[SERVER_NAME]).server);
+  return {
+    path,
+    exists: true,
+    servers: table && typeof table === "object" ? Object.keys(table).sort() : [],
+    ...ours ? { ours } : {}
+  };
+}
+function serverText(s, server) {
+  const id = storageId(s.path);
+  const other = id && server && storageId(server) && id !== storageId(server);
+  return `starts \`${s.path}\`: ${s.exists ? other ? `there, but another extension ID's copy (${id})` : "there" : "**missing**"}`;
+}
+async function folder(path) {
+  try {
+    const entries = await fs.readdir(path, { withFileTypes: true });
+    return {
+      path,
+      exists: true,
+      entries: entries.filter((e) => e.isDirectory() || e.isSymbolicLink()).map((e) => e.name).sort()
+    };
+  } catch {
+    return { path, exists: false, entries: [] };
+  }
+}
+async function hostConfigs(env, hosts = ["cursor", "antigravity", "windsurf", "kiro"]) {
+  return Promise.all(
+    hosts.map(async (id) => {
+      const info = HOSTS[id];
+      const plugins = info.plugins?.(env);
+      return {
+        host: id,
+        mcp: await Promise.all(info.mcp(env).map(mcpFile)),
+        skills: await Promise.all(info.skills(env).map(folder)),
+        ...plugins ? { plugins: await folder(plugins) } : {}
+      };
+    })
+  );
+}
+function configLines(c, server) {
+  const mark = (name) => name === SERVER_NAME || name === SKILL_NAME ? `**${name}**` : name;
+  const lines = [`### ${HOSTS[c.host].label} (${HOSTS[c.host].agent})`, ""];
+  for (const f of c.mcp)
+    lines.push(
+      `- MCP \`${f.path}\`: ${!f.exists ? "none" : f.broken ? "not valid JSON" : f.servers.length ? f.servers.map(mark).join(", ") : "no servers"}${f.ours ? `; ${SERVER_NAME} ${serverText(f.ours, server)}` : ""}`
+    );
+  for (const s of c.skills)
+    lines.push(
+      `- Skills \`${s.path}\`: ${!s.exists ? "none" : s.entries.map(mark).join(", ") || "empty"}`
+    );
+  if (c.plugins)
+    lines.push(
+      `- Plugins \`${c.plugins.path}\`: ${!c.plugins.exists ? "none" : c.plugins.entries.join(", ") || "empty"}`
+    );
+  lines.push(`- Note: ${HOSTS[c.host].note}`, "");
+  return lines;
+}
+async function agentRegistrations(env) {
+  return Promise.all(
+    AGENTS.map(async (agent) => {
+      const r = await registration(agent, env);
+      const file = await serverFile(r?.server);
+      return { agent: agentLabel(agent), registration: r, ...file ? { file } : {} };
+    })
+  );
+}
+function registrationLines(found, server) {
+  return found.map(({ agent, registration: r, file }) => {
+    if (!r) return `- ${agent}: not registered`;
+    const where = `- ${agent} \`${r.file}\``;
+    if (r.hand) return `${where}: written by hand; Set Up leaves it as it is`;
+    if (!file) return `${where}: starts \`${r.command ?? "?"}\`, not an mcp.js`;
+    return `${where}: ${serverText(file, server)}`;
+  });
+}
+export {
+  agentRegistrations,
+  configLines,
+  hostConfigs,
+  registrationLines
+};
+//# sourceMappingURL=hostConfig.js.map

package/dist/ai/hostConfig.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/node/ai/hostConfig.ts"],
+  "sourcesContent": ["// What each editor's agent is configured with on this machine (AFD-172): MCP servers by name, the\n// skills in its folders and its plugin bundles. Read-only, names only: a server entry's command,\n// arguments and environment (tokens) are never read out, except where ours starts (AFD-195).\nimport { promises as fs } from 'node:fs';\nimport { type ParseError, parse } from 'jsonc-parser';\nimport { agentLabel } from './agents';\nimport { HOSTS, type HostEnv, type HostId } from './hosts';\nimport {\n  AGENTS,\n  type Env,\n  entryServer,\n  type Registration,\n  registration,\n  SERVER_NAME,\n  SKILL_NAME,\n  storageId,\n} from './writers';\n\n/** AFD-195: the mcp.js our entry starts, and whether it is there. */\nexport interface ServerFile {\n  path: string;\n  exists: boolean;\n}\n\nconst fileExists = (path: string) =>\n  fs.stat(path).then(\n    () => true,\n    () => false,\n  );\n\nasync function serverFile(server: string | undefined): Promise<ServerFile | undefined> {\n  return server ? { path: server, exists: await fileExists(server) } : undefined;\n}\n\nexport interface McpFileState {\n  path: string;\n  exists: boolean;\n  /** Server names in it (mcpServers or servers). */\n  servers: string[];\n  /** Not JSON (with comments) the agent could read. */\n  broken?: boolean;\n  /** What our entry starts, when it starts an mcp.js. */\n  ours?: ServerFile;\n}\n\nexport interface FolderState {\n  path: string;\n  exists: boolean;\n  /** Entries in it: skill or plugin folder names. */\n  entries: string[];\n}\n\nexport interface HostConfig {\n  host: HostId;\n  mcp: McpFileState[];\n  skills: FolderState[];\n  plugins?: FolderState;\n}\n\nasync function mcpFile(path: string): Promise<McpFileState> {\n  let text: string;\n  try {\n    text = await fs.readFile(path, 'utf8');\n  } catch {\n    return { path, exists: false, servers: [] };\n  }\n  if (!text.trim()) return { path, exists: true, servers: [] };\n  const errors: ParseError[] = [];\n  const data = parse(text, errors, { allowTrailingComma: true }) as Record<string, unknown> | null;\n  if (errors.length > 0 || !data || typeof data !== 'object')\n    return { path, exists: true, servers: [], broken: true };\n  const table = (data.mcpServers ?? data.servers) as Record<string, unknown> | undefined;\n  const ours = await serverFile(entryServer(table?.[SERVER_NAME]).server);\n  return {\n    path,\n    exists: true,\n    servers: table && typeof table === 'object' ? Object.keys(table).sort() : [],\n    ...(ours ? { ours } : {}),\n  };\n}\n\n/** How a registered server file reads in the report. */\nfunction serverText(s: ServerFile, server?: string): string {\n  const id = storageId(s.path);\n  const other = id && server && storageId(server) && id !== storageId(server);\n  return `starts \\`${s.path}\\`: ${s.exists ? (other ? `there, but another extension ID's copy (${id})` : 'there') : '**missing**'}`;\n}\n\nasync function folder(path: string): Promise<FolderState> {\n  try {\n    const entries = await fs.readdir(path, { withFileTypes: true });\n    return {\n      path,\n      exists: true,\n      entries: entries\n        .filter((e) => e.isDirectory() || e.isSymbolicLink())\n        .map((e) => e.name)\n        .sort(),\n    };\n  } catch {\n    return { path, exists: false, entries: [] };\n  }\n}\n\n/** Each fork's MCP files, skill folders and plugin folder as they are now. */\nexport async function hostConfigs(\n  env: HostEnv,\n  hosts: HostId[] = ['cursor', 'antigravity', 'windsurf', 'kiro'],\n): Promise<HostConfig[]> {\n  return Promise.all(\n    hosts.map(async (id) => {\n      const info = HOSTS[id];\n      const plugins = info.plugins?.(env);\n      return {\n        host: id,\n        mcp: await Promise.all(info.mcp(env).map(mcpFile)),\n        skills: await Promise.all(info.skills(env).map(folder)),\n        ...(plugins ? { plugins: await folder(plugins) } : {}),\n      };\n    }),\n  );\n}\n\n/**\n * Markdown lines for one editor's configuration; ours is marked, with the server file it starts.\n * `server`: this extension's installed copy, to tell another extension ID's copy.\n */\nexport function configLines(c: HostConfig, server?: string): string[] {\n  const mark = (name: string) =>\n    name === SERVER_NAME || name === SKILL_NAME ? `**${name}**` : name;\n  const lines = [`### ${HOSTS[c.host].label} (${HOSTS[c.host].agent})`, ''];\n  for (const f of c.mcp)\n    lines.push(\n      `- MCP \\`${f.path}\\`: ${\n        !f.exists\n          ? 'none'\n          : f.broken\n            ? 'not valid JSON'\n            : f.servers.length\n              ? f.servers.map(mark).join(', ')\n              : 'no servers'\n      }${f.ours ? `; ${SERVER_NAME} ${serverText(f.ours, server)}` : ''}`,\n    );\n  for (const s of c.skills)\n    lines.push(\n      `- Skills \\`${s.path}\\`: ${!s.exists ? 'none' : s.entries.map(mark).join(', ') || 'empty'}`,\n    );\n  if (c.plugins)\n    lines.push(\n      `- Plugins \\`${c.plugins.path}\\`: ${!c.plugins.exists ? 'none' : c.plugins.entries.join(', ') || 'empty'}`,\n    );\n  lines.push(`- Note: ${HOSTS[c.host].note}`, '');\n  return lines;\n}\n\n/** AFD-195: each agent's ansible-flow entry as Set Up AI Assistants wrote it, and what it starts. */\nexport async function agentRegistrations(\n  env: Env,\n): Promise<{ registration: Registration | undefined; file?: ServerFile; agent: string }[]> {\n  return Promise.all(\n    AGENTS.map(async (agent) => {\n      const r = await registration(agent, env);\n      const file = await serverFile(r?.server);\n      return { agent: agentLabel(agent), registration: r, ...(file ? { file } : {}) };\n    }),\n  );\n}\n\n/** Markdown lines for agentRegistrations; `server` is this extension's installed copy. */\nexport function registrationLines(\n  found: Awaited<ReturnType<typeof agentRegistrations>>,\n  server: string,\n): string[] {\n  return found.map(({ agent, registration: r, file }) => {\n    if (!r) return `- ${agent}: not registered`;\n    const where = `- ${agent} \\`${r.file}\\``;\n    if (r.hand) return `${where}: written by hand; Set Up leaves it as it is`;\n    if (!file) return `${where}: starts \\`${r.command ?? '?'}\\`, not an mcp.js`;\n    return `${where}: ${serverText(file, server)}`;\n  });\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/ai/hosts.d.ts

@@ -0,0 +1,28 @@
+export type HostId = 'vscode' | 'cursor' | 'antigravity' | 'windsurf' | 'kiro' | 'other';
+export interface HostEnv {
+    home: string;
+    platform: NodeJS.Platform;
+    /** XDG_CONFIG_HOME, which Devin honours outside Windows. */
+    xdgConfig?: string;
+}
+export interface HostInfo {
+    id: HostId;
+    /** The editor, as people call it. */
+    label: string;
+    /** Its built-in agent. */
+    agent: string;
+    /** User-level MCP files the agent reads; the first is where an entry goes. */
+    mcp(env: HostEnv): string[];
+    /** User-level skill folders the agent reads (each holds one folder per skill). */
+    skills(env: HostEnv): string[];
+    /** Where plugin bundles go (plugin.json, MCP file, skills/), if the agent loads them. */
+    plugins?(env: HostEnv): string;
+    /** What is known and what is still to be probed. */
+    note: string;
+}
+export declare const HOSTS: Record<HostId, HostInfo>;
+/** Which editor this is, from vscode.env.appName and uriScheme (the scheme is the surer of the two). */
+export declare function detectHost(app: {
+    appName: string;
+    uriScheme: string;
+}): HostId;

package/dist/ai/hosts.js

@@ -0,0 +1,9 @@
+import {
+  HOSTS,
+  detectHost
+} from "../chunks/chunk-UNCR5JOZ.js";
+export {
+  HOSTS,
+  detectHost
+};
+//# sourceMappingURL=hosts.js.map

package/dist/ai/hosts.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/ai/writers.d.ts

@@ -0,0 +1,124 @@
+export declare const AGENTS: readonly ['claude', 'codex', 'gemini', 'opencode', 'zcode', 'copilot', 'cursor', 'kiro', 'antigravity', 'devin'];
+export type Agent = (typeof AGENTS)[number];
+export type Scope = 'repo' | 'user';
+export declare const SERVER_NAME = "ansible-flow";
+export declare const SKILL_NAME = "ansible-flow";
+/** How agents start the MCP server. */
+export interface Launch {
+    command: string;
+    args: string[];
+    env?: Record<string, string>;
+}
+export interface Item {
+    agent: Agent;
+    what: 'skill' | 'mcp';
+    /** File or folder, or the command for Claude's registration. */
+    target: string;
+    action: 'create' | 'update' | 'unchanged' | 'skip' | 'remove';
+    /** Why an item is skipped, or what the user must do. */
+    note?: string;
+}
+export interface Env {
+    home: string;
+    /** Where Devin keeps its MCP file depends on it (default: this process's platform). */
+    platform?: NodeJS.Platform;
+    /** XDG_CONFIG_HOME, which Devin honours outside Windows. */
+    xdgConfig?: string;
+    /** The repository (workspace folder) for repo-scope skill copies. */
+    repo?: string;
+    /** Runs the claude CLI; undefined when it is not installed. */
+    claude?: (args: string[]) => Promise<{
+        code: number;
+        out: string;
+    }>;
+}
+export interface SkillFiles {
+    version: string;
+    /** Relative path (posix) -> text. */
+    files: Record<string, string>;
+}
+/** Folders an agent reads the skill from, per scope. */
+export declare function skillDirs(agent: Agent, scope: Scope, env: Env): string[];
+export interface SkillState {
+    dir: string;
+    /** Not ours: the folder exists without our manifest. */
+    foreign: boolean;
+    version?: string;
+    /** Files of ours the user changed since they were written. */
+    edited: string[];
+}
+export declare function skillState(dir: string): Promise<SkillState | undefined>;
+/** a > b for versions like 0.75.0 (non-numeric parts count as 0). */
+export declare function newerVersion(a: string, b: string): boolean;
+export declare function planSkill(dir: string, skill: SkillFiles): Promise<Item['action']>;
+export declare function writeSkill(dir: string, skill: SkillFiles): Promise<void>;
+/** Removes our files (and the folder when nothing else is left in it); foreign folders stay. */
+export declare function removeSkill(dir: string): Promise<boolean>;
+export declare const codexConfig: (env: Env) => string;
+export declare function codexBlock(launch: Launch): string;
+export declare function planCodex(env: Env, launch: Launch): Promise<Item>;
+export declare function writeCodex(env: Env, launch: Launch): Promise<void>;
+export declare function removeCodex(env: Env): Promise<boolean>;
+type JsonAgent = Exclude<Agent, 'claude' | 'codex'>;
+/** Cursor's variable for the open folder, resolved by Cursor when it starts the server. */
+export declare const CURSOR_WORKSPACE = "${workspaceFolder}";
+/**
+ * Devin Desktop's MCP file, as its own code builds it: %USERPROFILE%\AppData\Roaming\devin on
+ * Windows, else $XDG_CONFIG_HOME/devin or ~/.config/devin. (It reads Windsurf's
+ * ~/.codeium/windsurf/mcp_config.json too, and Claude Code's and Cursor's entries.)
+ */
+export declare function devinMcpFile(env: Env): string;
+/** The config file an agent's registration goes in (Claude's is managed by its CLI). */
+export declare function mcpTarget(agent: Agent, env: Env, launch?: Launch): Promise<string>;
+export declare function planJson(agent: JsonAgent, env: Env, launch: Launch): Promise<Item>;
+export declare function writeJson(agent: JsonAgent, env: Env, launch: Launch): Promise<void>;
+export declare function removeJson(agent: JsonAgent, env: Env): Promise<boolean>;
+export declare function claudeAddArgs(launch: Launch): string[];
+/** The command a user runs when the claude CLI cannot be run from here. */
+export declare function claudeCommandLine(launch: Launch): string;
+export declare function planClaude(env: Env, launch: Launch): Promise<Item>;
+export declare function writeClaude(env: Env, launch: Launch): Promise<void>;
+export declare function removeClaude(env: Env): Promise<boolean>;
+/** Runs the claude CLI found at this path (a .cmd shim needs the shell, with quoted arguments). */
+export declare function claudeRunner(path: string): Env['claude'];
+/** The registration of the flow tools for one agent (no skill). */
+export declare function planMcp(agent: Agent, env: Env, launch: Launch): Promise<Item>;
+export declare function planSetup(agents: Agent[], scope: Scope, env: Env, launch: Launch, skill: SkillFiles): Promise<Item[]>;
+export declare function applySetup(items: Item[], env: Env, launch: Launch, skill: SkillFiles): Promise<void>;
+/** Removes skill copies (both scopes) and registrations of these agents; returns what went. */
+export declare function removeSetup(agents: Agent[], env: Env): Promise<Item[]>;
+/** Claude Code's user-scope servers, read from the file: `claude mcp get` starts the server. */
+export declare const claudeConfig: (env: Env) => string;
+/** What an agent's ansible-flow entry starts, read from its config file (never by running it). */
+export interface Registration {
+    agent: Agent;
+    /** The config file the entry is in. */
+    file: string;
+    command?: string;
+    /** The mcp.js it starts; none when it starts something else (npx, a script of the user's). */
+    server?: string;
+    /** Codex: a table the user wrote outside our block, which Set Up never changes. */
+    hand?: boolean;
+}
+/** The command and the mcp.js of an MCP entry: stdio (command, args) or OpenCode's command list. */
+export declare function entryServer(entry: unknown): {
+    command?: string;
+    server?: string;
+};
+export declare function registration(agent: Agent, env: Env): Promise<Registration | undefined>;
+/** The extension ID of a server copied into an editor's storage: …/globalStorage/<id>/mcp/mcp.js. */
+export declare function storageId(server: string): string | undefined;
+export interface StaleRegistration extends Registration {
+    server: string;
+    /** missing: the mcp.js is gone; elsewhere: another extension ID's copy (an older publisher). */
+    why: 'missing' | 'elsewhere';
+}
+/**
+ * Entries of ours that no longer start this server (`server`, this extension's installed copy):
+ * the mcp.js they name is gone, as when the publisher ID changed and the old ID's storage went
+ * with it, or it is another extension ID's copy. Only an entry that starts an mcp.js in an
+ * editor's global storage is ours: one the user wrote (a Codex table outside our block, a path of
+ * their own) is never reported. Another editor's copy under the same ID is not stale.
+ */
+export declare function staleRegistrations(agents: readonly Agent[], env: Env, server: string): Promise<StaleRegistration[]>;
+export {};

package/dist/ai/writers.js

@@ -0,0 +1,75 @@
+import {
+  AGENTS,
+  CURSOR_WORKSPACE,
+  SERVER_NAME,
+  SKILL_NAME,
+  applySetup,
+  claudeAddArgs,
+  claudeCommandLine,
+  claudeConfig,
+  claudeRunner,
+  codexBlock,
+  codexConfig,
+  devinMcpFile,
+  entryServer,
+  mcpTarget,
+  newerVersion,
+  planClaude,
+  planCodex,
+  planJson,
+  planMcp,
+  planSetup,
+  planSkill,
+  registration,
+  removeClaude,
+  removeCodex,
+  removeJson,
+  removeSetup,
+  removeSkill,
+  skillDirs,
+  skillState,
+  staleRegistrations,
+  storageId,
+  writeClaude,
+  writeCodex,
+  writeJson,
+  writeSkill
+} from "../chunks/chunk-2MZQHIXP.js";
+export {
+  AGENTS,
+  CURSOR_WORKSPACE,
+  SERVER_NAME,
+  SKILL_NAME,
+  applySetup,
+  claudeAddArgs,
+  claudeCommandLine,
+  claudeConfig,
+  claudeRunner,
+  codexBlock,
+  codexConfig,
+  devinMcpFile,
+  entryServer,
+  mcpTarget,
+  newerVersion,
+  planClaude,
+  planCodex,
+  planJson,
+  planMcp,
+  planSetup,
+  planSkill,
+  registration,
+  removeClaude,
+  removeCodex,
+  removeJson,
+  removeSetup,
+  removeSkill,
+  skillDirs,
+  skillState,
+  staleRegistrations,
+  storageId,
+  writeClaude,
+  writeCodex,
+  writeJson,
+  writeSkill
+};
+//# sourceMappingURL=writers.js.map

package/dist/ai/writers.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/autoLayout.d.ts

@@ -0,0 +1,38 @@
+import { type FlowModel, type Level } from '@ansible-flow/core/flow/model';
+import type { FlowDocument, Layout, Position, Ulid } from '@ansible-flow/core/flow/types';
+/** Top to bottom (the default) or left to right: the user setting `afd.canvas.direction` (AFD-42). */
+export type LayoutDirection = 'TB' | 'LR';
+/**
+ * Positions for every node of a level. Wires run port to port. Model order
+ * (`considerModelOrder`) and straightness priority on main outputs were tried for AFD-192: both
+ * gave more crossings on the fixtures, so ELK orders the layers by crossings alone.
+ */
+export declare function layoutLevel(level: Level, direction?: LayoutDirection): Promise<Record<Ulid, Position>>;
+/** ELK positions for every level of a new document, in the one flat layout map (ADR-0002). */
+export declare function layoutAll(doc: FlowDocument): Promise<void>;
+/**
+ * In-memory positions for nodes the layout block does not place (ADR-0002). With no stored
+ * positions at all the level gets a full ELK layout. Otherwise (AFD-23) the missing nodes keep
+ * ELK's shape around the placed ones: each goes where ELK puts it relative to a placed neighbour
+ * (its predecessor first), else by the placed nodes' median shift, and moves right while it would
+ * overlap a node. Before, each missing node went straight below its predecessor, so a flow with
+ * only Start and Done placed (the New Flow template) and everything else added by an AI agent
+ * stood in one column, siblings on top of each other.
+ */
+export declare function autoPositions(level: Level, layout: Layout | undefined, direction?: LayoutDirection): Promise<Record<Ulid, Position>>;
+/**
+ * The layout the canvas shows (AFD-23): the stored one, except that a level whose only positions
+ * are the New Flow template's (Start at 0,0 and Done at 36,160), while it has other nodes, is shown
+ * with a full auto-layout. Flows made before AFD-23 and then filled by an AI agent look like that.
+ * The shown positions are written on the first move or Tidy up, like any auto position.
+ */
+export declare function shownLayout(model: FlowModel): Layout | undefined;
+/**
+ * Where the canvas shows every node (AFD-24), for the AI tools: `stored` positions (the old
+ * template's dropped, as in the view) and `auto` positions for the rest, on every level. Pass the
+ * canvas direction (`afd.canvas.direction`) so the layout check sees what the canvas shows (AFD-192).
+ */
+export declare function shownPositions(model: FlowModel, direction?: LayoutDirection): Promise<{
+    stored: Layout;
+    auto: Record<Ulid, Position>;
+}>;