@duckmind/dm-windows-x64 0.63.4 → 0.63.9

package/extensions/dm-mcp-adapter/utils.js

@@ -0,0 +1,307 @@
+import { spawnSync } from "node:child_process";
+import { homedir, platform } from "node:os";
+import { extname, isAbsolute, join } from "node:path";
+async function execOpen(pi, target, browser, signal) {
+  const os = platform();
+  if (os === "darwin") {
+    if (browser) {
+      return isAbsolute(browser) && extname(browser).toLowerCase() !== ".app" ? pi.exec(browser, [target], signal ? { signal } : {}) : pi.exec("open", ["-a", browser, target], signal ? { signal } : {});
+    }
+    return pi.exec("open", [target], signal ? { signal } : {});
+  }
+  if (os === "win32") {
+    return browser ? pi.exec("cmd", ["/c", "start", "", browser, target], signal ? { signal } : {}) : pi.exec("cmd", ["/c", "start", "", target], signal ? { signal } : {});
+  }
+  return browser ? pi.exec(browser, [target], signal ? { signal } : {}) : pi.exec("xdg-open", [target], signal ? { signal } : {});
+}
+export async function openUrl(pi, url, browser, signal) {
+  const result = await execOpen(pi, url, browser, signal);
+  if (result.code !== 0) {
+    throw new Error(result.stderr || `Failed to open browser (exit code ${result.code})`);
+  }
+}
+export async function openPath(pi, targetPath) {
+  const result = await execOpen(pi, targetPath);
+  if (result.code !== 0) {
+    throw new Error(result.stderr || `Failed to open path (exit code ${result.code})`);
+  }
+}
+export async function parallelLimit(items, limit, fn) {
+  const results = [];
+  const iterator = items.entries();
+  async function worker() {
+    while (true) {
+      const next = iterator.next();
+      if (next.done)
+        return;
+      const [index, item] = next.value;
+      results[index] = await fn(item);
+    }
+  }
+  const workers = Array(Math.min(limit, items.length)).fill(null).map(() => worker());
+  await Promise.all(workers);
+  return results;
+}
+export function getConfigPathFromArgv() {
+  const idx = process.argv.indexOf("--mcp-config");
+  if (idx >= 0 && idx + 1 < process.argv.length) {
+    return process.argv[idx + 1];
+  }
+  return;
+}
+export function interpolateEnvVars(value, environment = process.env) {
+  return value.replace(/\$\{(\w+)\}/g, (_, name) => environment[name] ?? "").replace(/\$env:(\w+)/g, (_, name) => environment[name] ?? "").replace(/\{env:(\w+)\}/g, (_, name) => environment[name] ?? "");
+}
+function getMissingEnvVars(value, environment) {
+  const missing = new Set;
+  for (const match of value.matchAll(/\$\{(\w+)\}|\$env:(\w+)|\{env:(\w+)\}/g)) {
+    const name = match[1] ?? match[2] ?? match[3];
+    if (name && environment[name] === undefined) {
+      missing.add(name);
+    }
+  }
+  return [...missing];
+}
+export function toStringRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return;
+  const result = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (typeof entry === "string")
+      result[key] = entry;
+  }
+  return Object.keys(result).length > 0 ? result : undefined;
+}
+function interpolateSecretExpression(value, environment) {
+  if (value.startsWith("!!"))
+    return interpolateEnvVars(value.slice(1), environment);
+  return value.startsWith("!") ? value : interpolateEnvVars(value, environment);
+}
+export function interpolateEnvRecord(values, environment = process.env) {
+  if (!values)
+    return;
+  return Object.fromEntries(Object.entries(values).map(([key, value]) => [
+    key,
+    interpolateSecretExpression(value, environment)
+  ]));
+}
+const COMMAND_SECRET_TIMEOUT_MS = 1e4;
+const COMMAND_SECRET_MAX_OUTPUT_BYTES = 1024 * 1024;
+export function resolveCommandSecret(value, context) {
+  if (value === undefined)
+    return;
+  if (value.startsWith("!!"))
+    return interpolateEnvVars(value.slice(1));
+  if (!value.startsWith("!"))
+    return interpolateEnvVars(value);
+  const result = spawnSync(value.slice(1), {
+    shell: true,
+    encoding: "utf8",
+    timeout: COMMAND_SECRET_TIMEOUT_MS,
+    maxBuffer: COMMAND_SECRET_MAX_OUTPUT_BYTES,
+    stdio: ["ignore", "pipe", "ignore"],
+    windowsHide: true
+  });
+  if (result.error) {
+    const code = result.error.code;
+    const reason = code === "ETIMEDOUT" ? "command timed out after 10 seconds" : code === "ENOBUFS" ? "command output exceeded 1 MiB" : "command failed to start";
+    throw new Error(`Failed to resolve ${context}: ${reason}`);
+  }
+  if (result.status !== 0) {
+    throw new Error(`Failed to resolve ${context}: command exited with code ${result.status ?? "unknown"}`);
+  }
+  const resolved = result.stdout.trim();
+  if (!resolved)
+    throw new Error(`Failed to resolve ${context}: command returned empty output`);
+  return resolved;
+}
+export function resolveCommandSecretsRecord(values, context) {
+  if (!values)
+    return;
+  return Object.fromEntries(Object.entries(values).map(([key, value]) => [
+    key,
+    resolveCommandSecret(value, context(key))
+  ]));
+}
+export function resolveServerUrl(definition, environment = process.env) {
+  if (definition.url == null)
+    return;
+  if (typeof definition.url !== "string") {
+    throw new Error("MCP server URL must be a string");
+  }
+  const missing = getMissingEnvVars(definition.url, environment);
+  if (missing.length > 0) {
+    throw new Error(`Missing environment variable${missing.length === 1 ? "" : "s"} in MCP server URL: ${missing.join(", ")}`);
+  }
+  const resolved = interpolateEnvVars(definition.url, environment);
+  try {
+    new URL(resolved);
+  } catch (error) {
+    throw new Error(`Invalid MCP server URL after environment interpolation: ${resolved}`, { cause: error });
+  }
+  return resolved;
+}
+export function resolveConfigPath(value, environment = process.env) {
+  if (value === undefined)
+    return;
+  const resolved = interpolateEnvVars(value, environment);
+  if (resolved === "~")
+    return homedir();
+  if (resolved.startsWith("~/") || resolved.startsWith("~\\")) {
+    return join(homedir(), resolved.slice(2));
+  }
+  return resolved;
+}
+export function resolveBearerToken(definition, environment = process.env) {
+  if (definition.bearerToken !== undefined) {
+    return interpolateSecretExpression(definition.bearerToken, environment);
+  }
+  return definition.bearerTokenEnv ? environment[definition.bearerTokenEnv] : undefined;
+}
+export function stripOscSequences(text) {
+  let result = "";
+  let index = 0;
+  while (index < text.length) {
+    const isEscOsc = text.charCodeAt(index) === 27 && text[index + 1] === "]";
+    const isC1Osc = text.charCodeAt(index) === 157;
+    if (!isEscOsc && !isC1Osc) {
+      result += text[index++];
+      continue;
+    }
+    index += isEscOsc ? 2 : 1;
+    while (index < text.length) {
+      const code = text.charCodeAt(index++);
+      if (code === 7 || code === 156)
+        break;
+      if (code === 27 && text[index] === "\\") {
+        index++;
+        break;
+      }
+    }
+  }
+  return result;
+}
+export function sanitizeTerminalText(text) {
+  return stripOscSequences(text).replace(/(?:\x1b\[[0-?]*[ -/]*[@-~]|\x1b[@-Z\\-_])/g, "").replace(/[\u0000-\u001f\u007f-\u009f]+/g, " ").replace(/\s+/g, " ").trim();
+}
+export function formatTerminalError(error) {
+  const messages = [];
+  const seen = new Set;
+  const collect = (value) => {
+    if (seen.has(value))
+      return;
+    if (typeof value === "object" && value !== null || typeof value === "function")
+      seen.add(value);
+    if (value instanceof AggregateError) {
+      const countBefore = messages.length;
+      for (const nested of value.errors)
+        collect(nested);
+      if (value.cause !== undefined)
+        collect(value.cause);
+      if (messages.length === countBefore && value.message)
+        messages.push(value.message);
+      return;
+    }
+    if (value instanceof Error) {
+      if (value.message)
+        messages.push(value.message);
+      if (value.cause !== undefined)
+        collect(value.cause);
+      return;
+    }
+    messages.push(String(value));
+  };
+  collect(error);
+  return sanitizeTerminalText([...new Set(messages)].join(": "));
+}
+export function truncateAtWord(text, target) {
+  if (!text || text.length <= target)
+    return text;
+  const truncated = text.slice(0, target);
+  const lastSpace = truncated.lastIndexOf(" ");
+  if (lastSpace > target * 0.6) {
+    return truncated.slice(0, lastSpace) + "...";
+  }
+  return truncated + "...";
+}
+export function normalizeDirectToolInputSchema(schema) {
+  const inputSchema = schema && typeof schema === "object" && !Array.isArray(schema) ? schema : { type: "object", properties: {} };
+  const { $schema, additionalProperties, ...normalized } = inputSchema;
+  return normalized;
+}
+export function normalizeToolArguments(value, context = "tool arguments") {
+  if (value === undefined || value === null || value === "")
+    return {};
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed === "")
+      return {};
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch (error) {
+      throw new Error(`${context}: invalid args JSON (${error instanceof SyntaxError ? error.message : String(error)}); ` + `pass args as a JSON object, or as a valid JSON string encoding one`, { cause: error });
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error(`${context}: expected a JSON object, got ${Array.isArray(parsed) ? "array" : typeof parsed}`);
+    }
+    return parsed;
+  }
+  if (typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${context}: expected a JSON object, got ${Array.isArray(value) ? "array" : typeof value}`);
+  }
+  assertJsonSerializable(value, context);
+  try {
+    return JSON.parse(JSON.stringify(value));
+  } catch (error) {
+    throw new Error(`${context}: value is not JSON-serializable: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+  }
+}
+function assertJsonSerializable(value, context, path = "") {
+  if (value === null)
+    return;
+  if (typeof value === "string" || typeof value === "boolean")
+    return;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value))
+      throw new Error(`${context}: value at ${path || "root"} is not a finite number`);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const [index, item] of value.entries())
+      assertJsonSerializable(item, context, `${path}[${index}]`);
+    return;
+  }
+  if (typeof value === "object") {
+    if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) {
+      throw new Error(`${context}: value at ${path || "root"} is not a plain JSON object`);
+    }
+    if (Object.getOwnPropertySymbols(value).length > 0) {
+      throw new Error(`${context}: value at ${path || "root"} has symbol keys`);
+    }
+    for (const [key, item] of Object.entries(value)) {
+      assertJsonSerializable(item, context, path ? `${path}.${key}` : key);
+    }
+    return;
+  }
+  throw new Error(`${context}: value at ${path || "root"} is not JSON-serializable`);
+}
+export function formatAuthRequiredMessage(config, serverName, defaultMessage) {
+  const template = config.settings?.authRequiredMessage;
+  return template ? template.replaceAll("${server}", serverName) : defaultMessage;
+}
+export function formatMcpStatus(config, message) {
+  if (config.settings?.mcpFooterStatus === "off")
+    return;
+  return `${config.settings?.showStatusIcon === false ? "MCP: " : "\uD83D\uDD0C MCP: "}${message}`;
+}
+export function extractToolUiStreamMode(toolMeta) {
+  const uiMeta = toolMeta?.ui;
+  if (!uiMeta || typeof uiMeta !== "object")
+    return;
+  const streamMode = uiMeta["dm-mcp-adapter.streamMode"];
+  if (streamMode === "eager" || streamMode === "stream-first") {
+    return streamMode;
+  }
+  return;
+}

package/extensions/dm-skills-manager/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,27 @@
+# Third-party notices
+
+This package is based on ideas and portions of [`@kmiyh/pi-skills-menu`](https://github.com/Kmiyh/pi-skills-menu), which is licensed under the MIT License.
+
+```text
+MIT License
+
+Copyright (c) 2025 Kmiyh
+
+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/extensions/dm-skills-manager/extensions/skills-manager/components.js

@@ -0,0 +1,265 @@
+import {
+  Container,
+  Editor,
+  Key,
+  Markdown,
+  matchesKey,
+  Spacer,
+  Text,
+  truncateToWidth,
+  visibleWidth
+} from "@duckmind/dm-tui";
+import { getMarkdownTheme } from "@duckmind/dm-coding-agent";
+import { buildFrontmatterBlock } from "./format.js";
+import { glyphs } from "./glyphs.js";
+import { isDeletableSkill } from "./registry.js";
+import {
+  getEditorTheme,
+  inlineLine,
+  packageLabel,
+  padAnsi,
+  scopeLabel,
+  skillEntityTitle,
+  skillKeyHints,
+  skillLocation,
+  skillSelectedLine,
+  toneText,
+  renderFrame
+} from "./ui.js";
+
+export class SingleLineText {
+  text;
+  ellipsis;
+  constructor(text, ellipsis = "...") {
+    this.text = text;
+    this.ellipsis = ellipsis;
+  }
+  render(width) {
+    return [truncateToWidth(inlineLine(this.text), width, this.ellipsis)];
+  }
+  invalidate() {}
+}
+
+export class ListLineText {
+  text;
+  selected;
+  theme;
+  ellipsis;
+  constructor(text, selected, theme, ellipsis = "...") {
+    this.text = text;
+    this.selected = selected;
+    this.theme = theme;
+    this.ellipsis = ellipsis;
+  }
+  render(width) {
+    const line = truncateToWidth(inlineLine(this.text), width, this.ellipsis);
+    return [this.selected ? skillSelectedLine(this.theme, line, width) : line];
+  }
+  invalidate() {}
+}
+
+export class PrefixedEditor {
+  editor;
+  prefix;
+  constructor(editor, prefix = "> ") {
+    this.editor = editor;
+    this.prefix = prefix;
+  }
+  render(width) {
+    const rendered = this.editor.render(Math.max(1, width - this.prefix.length));
+    const lines = rendered.length >= 2 ? rendered.slice(1, -1) : rendered;
+    return lines.length === 0 ? [this.prefix] : lines.map((line, index) => `${index === 0 ? this.prefix : "  "}${line}`);
+  }
+  invalidate() {
+    this.editor.invalidate();
+  }
+}
+
+export class SearchInputLine {
+  input;
+  theme;
+  prefix;
+  constructor(input, theme, prefix = " ") {
+    this.input = input;
+    this.theme = theme;
+    this.prefix = prefix;
+  }
+  render(width) {
+    const inputWidth = Math.max(1, width - visibleWidth(this.prefix));
+    const line = truncateToWidth(`${this.prefix}${this.input.render(inputWidth)[0] ?? ""}`, width, "");
+    return [this.theme.bg("toolPendingBg", padAnsi(line, width))];
+  }
+  invalidate() {
+    this.input.invalidate();
+  }
+}
+
+export class ScrollableSkillPreview {
+  scrollOffset = 0;
+  lastInnerWidth = 1;
+  lastContentLines = [];
+  skill;
+  theme;
+  getTerminalRows;
+  constructor(skill, theme, getTerminalRows) {
+    this.skill = skill;
+    this.theme = theme;
+    this.getTerminalRows = getTerminalRows;
+  }
+  setSkill(skill) {
+    this.skill = skill;
+    this.scrollOffset = 0;
+    this.lastContentLines = [];
+  }
+  invalidate() {
+    this.lastContentLines = [];
+  }
+  maxHeight() {
+    return Math.max(10, Math.floor(this.getTerminalRows() * 0.78));
+  }
+  buildContentLines(innerWidth) {
+    const content = new Container;
+    const status = this.skill.enabled ? this.theme.fg("success", "enabled") : this.theme.fg("warning", "disabled");
+    const source = packageLabel(this.skill) ? `${packageLabel(this.skill)}` : this.skill.path;
+    content.addChild(new Text(skillEntityTitle(this.theme, this.skill.name), 0, 0));
+    content.addChild(new Text(`${this.theme.fg("muted", scopeLabel(this.skill))}${this.theme.fg("dim", ` ${glyphs().bullet.trim()} `)}${this.theme.fg("muted", source)}${this.theme.fg("dim", ` ${glyphs().bullet.trim()} `)}${status}`, 0, 0));
+    content.addChild(new Spacer(1));
+    content.addChild(new Text(this.theme.fg("muted", this.theme.bold("Description")), 0, 0));
+    content.addChild(new Text(this.skill.description, 0, 0));
+    content.addChild(new Spacer(1));
+    content.addChild(new Text(this.theme.fg("muted", this.theme.bold("Metadata")), 0, 0));
+    content.addChild(new Text(this.theme.fg("dim", buildFrontmatterBlock(this.skill)), 0, 0));
+    content.addChild(new Spacer(1));
+    content.addChild(new Text(this.theme.fg("muted", this.theme.bold("Content")), 0, 0));
+    content.addChild(new Spacer(1));
+    content.addChild(new Markdown(this.skill.content || this.theme.fg("dim", "(empty skill body)"), 0, 0, getMarkdownTheme()));
+    const lines = content.render(innerWidth);
+    this.lastInnerWidth = innerWidth;
+    this.lastContentLines = lines;
+    return lines;
+  }
+  footer(innerWidth, visibleHeight, totalLines) {
+    const maxScroll = Math.max(0, totalLines - visibleHeight);
+    const scroll = maxScroll > 0 ? this.theme.fg("dim", ` ${glyphs().bullet.trim()} ${this.scrollOffset + 1}-${Math.min(totalLines, this.scrollOffset + visibleHeight)}/${totalLines}`) : "";
+    const hints = [["-/=", "page"]];
+    hints.push(["ctrl+x", "enable/disable"]);
+    if (isDeletableSkill(this.skill))
+      hints.push(["alt+e", "edit"], ["alt+r", "rename"], ["backspace", "delete"]);
+    return truncateToWidth(`${skillKeyHints(this.theme, hints)}${scroll}`, innerWidth, this.theme.fg("dim", "..."));
+  }
+  render(width) {
+    if (width < 8)
+      return [];
+    const innerWidth = Math.max(1, width - 4);
+    const visibleHeight = Math.max(1, this.maxHeight() - 3);
+    const contentLines = this.buildContentLines(innerWidth);
+    const maxScroll = Math.max(0, contentLines.length - visibleHeight);
+    this.scrollOffset = Math.max(0, Math.min(this.scrollOffset, maxScroll));
+    const visible = contentLines.slice(this.scrollOffset, this.scrollOffset + visibleHeight);
+    return renderFrame(this.theme, width, [...visible, this.footer(innerWidth, visibleHeight, contentLines.length)]);
+  }
+  handleInput(data) {
+    const visibleHeight = Math.max(1, this.maxHeight() - 3);
+    const total = this.lastContentLines.length || this.buildContentLines(this.lastInnerWidth).length;
+    const maxScroll = Math.max(0, total - visibleHeight);
+    if (matchesKey(data, Key.up))
+      this.scrollOffset = Math.max(0, this.scrollOffset - 1);
+    else if (matchesKey(data, Key.down))
+      this.scrollOffset = Math.min(maxScroll, this.scrollOffset + 1);
+    else if (matchesKey(data, "-") || matchesKey(data, Key.pageUp))
+      this.scrollOffset = Math.max(0, this.scrollOffset - visibleHeight);
+    else if (matchesKey(data, "=") || matchesKey(data, Key.pageDown))
+      this.scrollOffset = Math.min(maxScroll, this.scrollOffset + visibleHeight);
+    else if (matchesKey(data, Key.home))
+      this.scrollOffset = 0;
+    else if (matchesKey(data, Key.end))
+      this.scrollOffset = maxScroll;
+  }
+}
+
+export class SkillEditorView {
+  editor;
+  initialText;
+  proxyTui;
+  skill;
+  theme;
+  realTui;
+  onSave;
+  onCancel;
+  virtualRows = 24;
+  _focused = false;
+  message;
+  get focused() {
+    return this._focused;
+  }
+  set focused(value) {
+    this._focused = value;
+    this.editor.focused = value;
+  }
+  constructor(skill, theme, realTui, initialText, onSave, onCancel) {
+    this.skill = skill;
+    this.theme = theme;
+    this.realTui = realTui;
+    this.onSave = onSave;
+    this.onCancel = onCancel;
+    this.initialText = initialText;
+    const self = this;
+    this.proxyTui = { requestRender: () => realTui.requestRender(), get terminal() {
+      return { ...realTui.terminal, rows: Math.max(1, self.virtualRows) };
+    } };
+    this.editor = new Editor(this.proxyTui, getEditorTheme(theme), { autocompleteMaxVisible: 6 });
+    this.editor.setText(initialText);
+  }
+  setSkill(skill) {
+    this.skill = skill;
+  }
+  setMessage(text, tone) {
+    this.message = { text, tone };
+  }
+  isDirty() {
+    return this.editor.getText() !== this.initialText;
+  }
+  invalidate() {
+    this.editor.invalidate();
+  }
+  targetHeight() {
+    return Math.max(10, Math.floor(this.realTui.terminal.rows * 0.78));
+  }
+  rowsForVisibleEditorLines(targetVisibleLines) {
+    let rows = 5;
+    while (Math.max(5, Math.floor(rows * 0.3)) < targetVisibleLines && rows < 1000)
+      rows += 1;
+    return rows;
+  }
+  render(width) {
+    const innerWidth = Math.max(1, width - 4);
+    const lines = [
+      skillEntityTitle(this.theme, `Edit ${this.skill.name}`),
+      this.theme.fg("muted", skillLocation(this.skill)),
+      this.theme.fg("dim", `Name is immutable here: ${this.skill.name}`)
+    ];
+    if (this.message)
+      lines.push("", toneText(this.theme, this.message.tone, this.message.text));
+    const targetInnerLines = Math.max(1, this.targetHeight() - 2);
+    const staticLineCount = lines.length + 3;
+    const editorBlockLines = Math.max(7, targetInnerLines - staticLineCount);
+    this.virtualRows = this.rowsForVisibleEditorLines(Math.max(5, editorBlockLines - 2));
+    lines.push("", ...this.editor.render(innerWidth), "", truncateToWidth(skillKeyHints(this.theme, [["alt+s", "save"]]), innerWidth, this.theme.fg("dim", "...")));
+    while (lines.length < targetInnerLines)
+      lines.splice(Math.max(0, lines.length - 1), 0, "");
+    return renderFrame(this.theme, width, lines.slice(0, targetInnerLines));
+  }
+  handleInput(data) {
+    if (matchesKey(data, Key.escape)) {
+      this.onCancel();
+      return;
+    }
+    if (matchesKey(data, Key.alt("s")) || matchesKey(data, Key.ctrl("s"))) {
+      this.onSave(this.editor.getText());
+      return;
+    }
+    if (this.message?.tone === "error")
+      this.message = undefined;
+    this.editor.handleInput(data);
+  }
+}

package/extensions/dm-skills-manager/extensions/skills-manager/constants.js

@@ -0,0 +1,31 @@
+export const PACKAGE_ID = "@vanillagreen/dm-skills-manager";
+export const INSTALL_SYMBOL = Symbol.for("kendex.dm-skills-manager.installed");
+export const STARTUP_PATCH_SYMBOL = Symbol.for("kendex.dm-skills-manager.startup-patch");
+export const STARTUP_HIDE_ENABLED_SYMBOL = Symbol.for("kendex.dm-skills-manager.hide-startup-skills");
+export const KENDEX_MODAL_LOCK_SYMBOL = Symbol.for("kendex.dm.modal-lock");
+export const DEFAULT_POPUP_WIDTH = "82%";
+export const DEFAULT_POPUP_MAX_HEIGHT = "86%";
+export const DEFAULT_LIST_ROWS = 14;
+const ANSI_GREEN_FG = "\x1B[32m";
+const ANSI_YELLOW_FG = "\x1B[33m";
+const ANSI_FG_RESET = "\x1B[39m";
+export function ansiGreen(text) {
+  return `${ANSI_GREEN_FG}${text}${ANSI_FG_RESET}`;
+}
+export function ansiYellow(text) {
+  return `${ANSI_YELLOW_FG}${text}${ANSI_FG_RESET}`;
+}
+export const GENERATE_SKILL_SYSTEM_PROMPT = `You create production-ready DM Agent skills.
+
+Return only a complete SKILL.md file. Do not wrap it in fences. Do not add commentary.
+
+Rules:
+- Start with YAML frontmatter containing name and description.
+- The frontmatter name must exactly match the provided skill_slug.
+- The description is the trigger surface: state what the skill does and when DM should use it.
+- Include allowed-tools only if provided, as one space-delimited string.
+- Keep the body concise, operational, and reusable.
+- Prefer workflows, decision rules, output expectations, constraints, edge cases, and final checks.
+- Do not add placeholders, TODOs, fake files, or ungrounded scripts/references.
+- Use relative paths only if the user explicitly grounded extra files.
+- Do not mention skill-authoring infrastructure, package managers, or this generation process.`;

package/extensions/dm-skills-manager/extensions/skills-manager/creation-fallback.js

@@ -0,0 +1,20 @@
+export function isAbortError(error) {
+  if (!error || typeof error !== "object")
+    return false;
+  const name = "name" in error ? String(error.name) : "";
+  const message = "message" in error ? String(error.message) : "";
+  return name === "AbortError" || message.toLowerCase().includes("aborted");
+}
+export async function resolveSkillDraft(generate, fallback, signal, onFallback) {
+  if (signal?.aborted)
+    return null;
+  try {
+    const draft = await generate();
+    return signal?.aborted ? null : draft;
+  } catch (error) {
+    if (signal?.aborted || isAbortError(error))
+      return null;
+    onFallback(error);
+    return fallback();
+  }
+}