agentwheel 0.14.7 → 0.14.9

package/dist/index.js

@@ -143,6 +143,20 @@ function supportedInstallationTypes(adapter, artifactType) {
   }
   return [...types].sort((a, b) => a.localeCompare(b));
 }
+function adapterTargetSupport(adapter, artifactType, installationType) {
+  if (artifactType === "fragments") return { ok: true };
+  const registry = adapter.targets[artifactType];
+  const supported = supportedInstallationTypes(adapter, artifactType);
+  if (!registry) {
+    return { ok: false, reason: "adapter-target-unsupported", supportedInstallationTypes: supported };
+  }
+  const target = registry[installationType];
+  if (target?.enabled) return { ok: true };
+  if (target && !target.enabled) {
+    return { ok: false, reason: "adapter-target-disabled", supportedInstallationTypes: supported };
+  }
+  return { ok: false, reason: "adapter-target-unsupported", supportedInstallationTypes: supported };
+}
 function resolveInstallationTypeForArtifacts(adapter, artifactTypes, requested) {
   const installableTypes = [...new Set(artifactTypes.filter((type) => type !== "fragments"))];
   if (installableTypes.length === 0) {
@@ -1256,6 +1270,23 @@ async function removeApplyJournal(targetRoot, adapter, transport = localTranspor
   await transport.rm(applyJournalPath(targetRoot, adapter, scope));
   await transport.rm(applyBackupDir(targetRoot, adapter, scope));
 }
+async function abortApplyJournal(targetRoot, adapter, transport = localTransport, scope = {}) {
+  const lock = await acquireApplyLock(targetRoot, adapter, transport, {}, scope);
+  try {
+    const journalPath = applyJournalPath(targetRoot, adapter, scope);
+    if (!await transport.pathExists(journalPath)) return void 0;
+    const stateKey = stateKeyFor(adapter, scope);
+    const archivePath = join3(metadataDir(targetRoot), "archive", `${stateKey}.apply-journal.failed-${journalTimestamp(/* @__PURE__ */ new Date())}.json`);
+    const content = await transport.readFile(journalPath);
+    await transport.writeFileAtomic(archivePath, content.endsWith("\n") ? content : `${content}
+`);
+    await transport.rm(journalPath);
+    await transport.rm(applyBackupDir(targetRoot, adapter, scope));
+    return { journalPath, archivePath };
+  } finally {
+    await lock.release();
+  }
+}
 async function recordBackup(operation, index, targetRoot, adapter, transport = localTransport, scope = {}) {
   const hadExisting = await transport.pathExists(operation.destPath);
   if (!hadExisting || transport.kind !== "local" || operation.action !== "update" && operation.action !== "remove" && operation.action !== "create") {
@@ -1312,6 +1343,9 @@ async function readLockOwner(ownerPath, transport) {
 function isAlreadyExists(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
 }
+function journalTimestamp(date) {
+  return date.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+}
 async function localPathExists(path) {
   try {
     await stat2(path);
@@ -2024,7 +2058,12 @@ async function executePluginInstall(operation, transport) {
 async function executePluginUninstall(operation, transport) {
   const commands = operation.semanticPlugin?.uninstallCommands ?? [];
   if (commands.length === 0) throw new Error(`Invalid semantic plugin operation missing uninstall command: ${operation.relativeDestPath}`);
-  await executeSemanticCommands(operation, commands, transport);
+  try {
+    await executeSemanticCommands(operation, commands, transport);
+  } catch (error) {
+    if (!isPluginAlreadyAbsentError(operation, error)) throw error;
+    console.warn(`WARNING plugin-already-absent ${operation.relativeDestPath}: ${firstErrorLine(error)}`);
+  }
   if (operation.semanticPlugin?.stateRoot) {
     await transport.rm(operation.semanticPlugin.stateRoot);
   }
@@ -2171,6 +2210,35 @@ async function executeSemanticCommands(operation, commands, transport, options =
     await transport.rm(stagingRoot);
   }
 }
+function isPluginAlreadyAbsentError(operation, error) {
+  const output = commandErrorOutput(error).toLowerCase();
+  if (!output || output.includes("command not found") || output.includes("module not found")) return false;
+  const pluginName = (operation.semanticPlugin?.pluginName ?? operation.artifactName).toLowerCase();
+  const escapedName = escapeRegExp(pluginName);
+  const namedAbsent = [
+    new RegExp(`${escapedName}.{0,120}\\b(not installed|not found|does not exist|absent)\\b`, "s"),
+    new RegExp(`\\b(not installed|not found|does not exist|absent)\\b.{0,120}${escapedName}`, "s"),
+    new RegExp(`\\bunknown plugin\\b.{0,120}${escapedName}`, "s"),
+    new RegExp(`${escapedName}.{0,120}\\bunknown plugin\\b`, "s")
+  ].some((pattern) => pattern.test(output));
+  const genericAbsent = /\b(no such|unknown)\s+plugins?\b/.test(output) || /\bplugins?\b.{0,80}\bnot installed\b/s.test(output);
+  return namedAbsent || genericAbsent;
+}
+function commandErrorOutput(error) {
+  if (typeof error === "object" && error !== null) {
+    const stderr = "stderr" in error ? String(error.stderr ?? "") : "";
+    if (stderr.trim()) return stderr;
+    const stdout = "stdout" in error ? String(error.stdout ?? "") : "";
+    if (stdout.trim()) return stdout;
+  }
+  return error instanceof Error ? error.message : String(error);
+}
+function firstErrorLine(error) {
+  return commandErrorOutput(error).split(/\r?\n/).map((line) => line.trim()).find(Boolean) ?? "plugin is already absent";
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function semanticInstallCommands(operation) {
   if (operation.semanticPlugin) return operation.semanticPlugin.installCommands;
   return operation.semanticCommand ? [operation.semanticCommand] : [];
@@ -2416,7 +2484,7 @@ function codexAgentName(artifact) {
 }
 function validateCodexAgentToml(content, path) {
   for (const field of requiredCodexAgentFields) {
-    const pattern = new RegExp(`(^|\\n)\\s*${escapeRegExp(field)}\\s*=`, "m");
+    const pattern = new RegExp(`(^|\\n)\\s*${escapeRegExp2(field)}\\s*=`, "m");
     if (!pattern.test(content)) {
       throw new Error(`Codex custom agent TOML ${path} is missing required field '${field}'.`);
     }
@@ -2462,7 +2530,7 @@ function tomlMultilineString(value) {
 ${escaped.endsWith("\n") ? escaped : `${escaped}
 `}"""`;
 }
-function escapeRegExp(value) {
+function escapeRegExp2(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
@@ -2867,11 +2935,6 @@ async function semanticPluginSpecForArtifact(request) {
   return void 0;
 }
 
-// src/validation/artifacts.ts
-import { readFile as readFile15 } from "fs/promises";
-import { basename as basename7, join as join15 } from "path";
-import { parseDocument as parseDocument2 } from "yaml";
-
 // src/model/selection.ts
 function artifactSelectorKey(artifact) {
   return `${artifact.type}/${artifact.name}`;
@@ -2922,7 +2985,51 @@ function subagentBaseName(name) {
   return name.replace(/\.agent\.md$/i, "").replace(/\.toml$/i, "").replace(/\.md$/i, "");
 }
 
+// src/validation/adapter-targets.ts
+function filterArtifactsByAdapterTargets(artifacts, adapter, installationType, options = {}) {
+  const skipped = [];
+  const installable = artifacts.filter((artifact) => {
+    if (artifact.type === "fragments") return true;
+    const support = adapterTargetSupport(adapter, artifact.type, installationType);
+    if (support.ok) return true;
+    const selector = artifactSelectorKey(artifact);
+    skipped.push({ selector, artifactType: artifact.type, support });
+    options.warn?.(skipWarning(selector, adapter, installationType, artifact.type, support));
+    return false;
+  });
+  const before = artifacts.filter((artifact) => artifact.type !== "fragments");
+  const after = installable.filter((artifact) => artifact.type !== "fragments");
+  if (before.length > 0 && after.length === 0) {
+    throw new Error(
+      `${unsupportedSummary(adapter, installationType, skipped)} No installable artifacts remain for adapter ${adapter.name}/${installationType} after skipping unsupported targets: ${skipped.map((item) => item.selector).join(", ")}`
+    );
+  }
+  return installable;
+}
+function unsupportedSummary(adapter, installationType, skipped) {
+  const types = [...new Set(skipped.map((item) => item.artifactType))].sort((a, b) => a.localeCompare(b));
+  if (types.length !== 1) {
+    return `Adapter ${adapter.name} does not support selected artifact targets for installation type '${installationType}'.`;
+  }
+  const type = types[0];
+  const supported = [...new Set(skipped.flatMap((item) => item.support.supportedInstallationTypes))].sort((a, b) => a.localeCompare(b));
+  if (supported.length > 0) {
+    return `Adapter ${adapter.name} does not support ${type} artifacts for installation type '${installationType}'. Supported: ${supported.join(", ")}.`;
+  }
+  return `Adapter ${adapter.name} does not support ${type} artifacts for any installation type.`;
+}
+function skipWarning(selector, adapter, installationType, artifactType, support) {
+  if (support.reason === "adapter-target-disabled") {
+    return `skip ${selector} (selected but adapter-target-disabled: ${adapter.name}/${installationType} disables ${artifactType})`;
+  }
+  const suffix = support.supportedInstallationTypes.length > 0 ? `; supported installation types: ${support.supportedInstallationTypes.join(", ")}` : "";
+  return `skip ${selector} (selected but adapter-target-unsupported: ${adapter.name}/${installationType} has no enabled target for ${artifactType}${suffix})`;
+}
+
 // src/validation/artifacts.ts
+import { readFile as readFile15 } from "fs/promises";
+import { basename as basename7, join as join15 } from "path";
+import { parseDocument as parseDocument2 } from "yaml";
 var behavioralRuleFormats = ["markdown-rule", "claude-markdown-rule", "copilot-instruction-rule"];
 var pluginFormats = ["claude-plugin", "codex-plugin", "hermes-plugin", "copilot-plugin", "openclaw-plugin", "openclaw-clawhub-plugin"];
 async function filterArtifactsByInstallFormat(artifacts, adapter, installationType, options = {}) {
@@ -3380,7 +3487,10 @@ function errorMessage(error) {
 // src/install/plan.ts
 async function createCombinedInstallPlan(desiredArtifacts, adapter, targetRoot, manifest, transport = localTransport, options = {}) {
   const requestedInstallationType = options.installationType ?? defaultInstallationType;
-  const installableArtifacts = await filterArtifactsByInstallFormat(desiredArtifacts, adapter, requestedInstallationType, { warn: options.warn });
+  const formatCompatibleArtifacts = await filterArtifactsByInstallFormat(desiredArtifacts, adapter, requestedInstallationType, { warn: options.warn });
+  const installableArtifacts = filterArtifactsByAdapterTargets(formatCompatibleArtifacts, adapter, requestedInstallationType, {
+    warn: options.suppressAdapterTargetWarnings ? void 0 : options.warn
+  });
   const installationType = resolveInstallationTypeForArtifacts(adapter, installableArtifacts.map((artifact) => artifact.type), requestedInstallationType);
   const installRoot = installRootForArtifacts(adapter, targetRoot, installationType, installableArtifacts.map((artifact) => artifact.type), transport.kind === "ssh");
   await validateArtifactsForInstall(installableArtifacts, adapter, installationType);
@@ -6299,6 +6409,8 @@ var workspaceTrustSchema = z6.object({
 }).default({});
 var workspaceAgentSchema = z6.object({
   adapter: z6.string().min(1),
+  adapterConfig: z6.string().min(1).optional(),
+  adapterModule: z6.string().min(1).optional(),
   root: z6.string().min(1),
   installationType: installationTypeSchema.optional(),
   transport: z6.enum(["local", "ssh"]).default("local"),
@@ -8354,7 +8466,12 @@ async function createGraphSourcePlan(options) {
     targetFingerprint,
     warn
   });
-  const desiredArtifacts = desiredArtifactsFromGraphBundle(bundle);
+  const desiredArtifacts = filterArtifactsByAdapterTargets(
+    desiredArtifactsFromGraphBundle(bundle),
+    options.adapter,
+    installationType,
+    { warn }
+  );
   const resolvedInstallationType = resolveInstallationTypeForArtifacts(options.adapter, desiredArtifacts.map((artifact) => artifact.type), installationType);
   const resolvedInstallRoot = installRootForArtifacts(options.adapter, options.targetRoot, resolvedInstallationType, desiredArtifacts.map((artifact) => artifact.type), transport.kind === "ssh");
   const graphLockDigest = digestGraphLock(bundle.graphLock);
@@ -8622,6 +8739,8 @@ function targetFromAgent(name, config, workspaceRoot, installationType) {
     agentName: name,
     targetKey: name,
     adapter: agent.adapter,
+    adapterConfig: agent.adapterConfig,
+    adapterModule: agent.adapterModule,
     installationType: installationType ?? agent.installationType,
     targetRoot: agent.transport === "ssh" ? agent.root : resolveConfigPath(agent.root, workspaceRoot),
     workspaceRoot,
@@ -9449,6 +9568,38 @@ program.command("status").description("show configured packages and runtime inst
     await printStatus(target, normalizedOptions);
   }
 });
+var journalCommand = program.command("journal").description("inspect or abort pending apply journals");
+journalCommand.command("list").description("show pending apply journals for resolved runtime targets").option("--adapter <adapter>", "built-in adapter or comma-separated adapters").option("-i, --installation-type <type>", "installation type (for example local or user)").option("--user", "shortcut for --installation-type user and home-scoped state", false).option("--local", "shortcut for --installation-type local", false).option("--adapter-config <path>", "adapter JSON/JSONC file").option("--adapter-module <path>", "local programmatic adapter module").option("--allow-adapter-code", "allow loading local adapter code", false).option("-t, --target-root <path>", "runtime/project root").option("--agent <name>", "named agent from merged config").option("--all", "run for every configured agent", false).option("--profile <name>", "workspace runtime profile").action(async (options) => {
+  const normalizedOptions = normalizeRuntimeScopeOptions(options);
+  const targets = await resolveCliTargets(normalizedOptions, { preferAllProfile: true });
+  let pending = 0;
+  for (const target of targets) {
+    const state = await journalStateForTarget(target, normalizedOptions);
+    const journal = await readApplyJournal(state.installRoot, state.adapter.name, state.transport, state.state);
+    if (!journal) continue;
+    pending += 1;
+    console.log(`PENDING ${state.adapter.name}/${state.installationType} at ${state.installRoot}`);
+    console.log(`  journal: ${join41(state.installRoot, ".agentwheel", `${state.state.stateKey}.apply-journal.json`)}`);
+    console.log(`  stateKey: ${state.state.stateKey}`);
+    console.log(`  createdAt: ${journal.createdAt}`);
+    console.log(`  updatedAt: ${journal.updatedAt}`);
+    console.log(`  operations: ${journal.operations.length}, completed: ${journal.completed.length}`);
+  }
+  if (pending === 0) console.log("No pending apply journals.");
+});
+journalCommand.command("abort").description("archive pending apply journals without touching runtime files").option("--adapter <adapter>", "built-in adapter or comma-separated adapters").option("-i, --installation-type <type>", "installation type (for example local or user)").option("--user", "shortcut for --installation-type user and home-scoped state", false).option("--local", "shortcut for --installation-type local", false).option("--adapter-config <path>", "adapter JSON/JSONC file").option("--adapter-module <path>", "local programmatic adapter module").option("--allow-adapter-code", "allow loading local adapter code", false).option("-t, --target-root <path>", "runtime/project root").option("--agent <name>", "named agent from merged config").option("--all", "run for every configured agent", false).option("--profile <name>", "workspace runtime profile").action(async (options) => {
+  const normalizedOptions = normalizeRuntimeScopeOptions(options);
+  const targets = await resolveCliTargets(normalizedOptions, { preferAllProfile: true });
+  let aborted = 0;
+  for (const target of targets) {
+    const state = await journalStateForTarget(target, normalizedOptions);
+    const result = await abortApplyJournal(state.installRoot, state.adapter.name, state.transport, state.state);
+    if (!result) continue;
+    aborted += 1;
+    console.log(`Archived ${state.adapter.name}/${state.installationType} pending journal: ${result.archivePath}`);
+  }
+  if (aborted === 0) console.log("No pending apply journals.");
+});
 program.command("doctor").description("check agentwheel runtime setup and companion skill guidance").option("--adapter <adapter>", "built-in adapter").option("-i, --installation-type <type>", "installation type (for example local or user)").option("--user", "shortcut for --installation-type user and home-scoped state", false).option("--local", "shortcut for --installation-type local", false).option("-t, --target-root <path>", "runtime/project root").option("--agent <name>", "named agent from merged config").option("--adapter-config <path>", "adapter JSON/JSONC file").option("--adapter-module <path>", "local programmatic adapter module").option("--allow-adapter-code", "allow loading local adapter code", false).option("--skill <name>", "check a specific skill by name (repeatable or comma-separated)", collectSkillOption, []).option("--source <source>", "source to use in suggested install commands").option("--json", "print machine-readable doctor report", false).action(async (options) => {
   const normalizedOptions = normalizeRuntimeScopeOptions(options);
   const target = await resolveRuntimeTarget({
@@ -10141,6 +10292,14 @@ async function printStatus(target, options) {
   }
   await printPendingInstallWork(target, options);
 }
+async function journalStateForTarget(target, options) {
+  const adapterOptions = adapterOptionsForTarget(target, options);
+  const adapter = await resolveAdapterForTarget(target, adapterOptions);
+  const transport = transportForTarget(target);
+  const installationType = options.installationType ?? target.installationType ?? resolveInstallationTypeForAdapter(adapter);
+  const state = installStateForTarget(target, adapter, adapterOptions, installationType);
+  return { adapter, transport, installationType, installRoot: state.installRoot, state };
+}
 async function printPendingInstallWork(target, options) {
   let results = [];
   try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentwheel",
-  "version": "0.14.7",
+  "version": "0.14.9",
   "description": "Weave skills, rules, and instructions across every AI agent.",
   "type": "module",
   "license": "MIT",