@klhapp/skillmux 1.12.0 → 1.13.0

package/src/commands/install.ts

@@ -1,155 +0,0 @@
-import { rmSync } from "node:fs";
-import { join } from "node:path";
-import { expandHome, loadConfig } from "../config";
-import {
-  assertHostAllowed,
-  cloneToTemp,
-  deriveRepoName,
-  installIntoVault,
-  isLocalFileUrl,
-  resolveCloneCommit,
-  resolveRepoSource,
-  resolveSkillDir,
-  validateSkillCandidate,
-} from "../install";
-import { emitSuccess } from "../output";
-import { hashSkillContent, writeSkillOrigin } from "../provenance";
-import {
-  FAIL_ON_USAGE,
-  parseFailOn,
-  renderScanText,
-  resolveMutatingFailOn,
-  scanExitCode,
-  type FailOnOption,
-} from "../scan";
-import { isGlobalFlag } from "../global-flags";
-import { confirmIfNeeded } from "./shared";
-
-function parseInstallArgs(args: string[]): {
-  repo?: string;
-  force: boolean;
-  dryRun: boolean;
-  failOn?: FailOnOption;
-  allowLocalSource: boolean;
-  yes: boolean;
-} {
-  let repo: string | undefined;
-  let force = false;
-  let dryRun = false;
-  let failOn: FailOnOption | undefined;
-  let allowLocalSource = false;
-  let yes = false;
-  for (let i = 0; i < args.length; i++) {
-    const option = args[i];
-    if (option === "--force") force = true;
-    else if (option === "--yes") yes = true;
-    else if (option === "--dry-run") dryRun = true;
-    else if (option === "--allow-local-source") allowLocalSource = true;
-    else if (option === "--fail-on") {
-      failOn = parseFailOn(args[++i]);
-    } else if (isGlobalFlag(option, "--json", "--verbose")) {
-      // handled globally by main()'s isJson/isVerbose flags; recognized here so they aren't rejected
-    } else if (option?.startsWith("--")) {
-      throw new Error(`unknown install option: ${option}`);
-    } else if (repo !== undefined) {
-      throw new Error("skillmux install accepts at most one <repo> argument");
-    } else {
-      repo = option;
-    }
-  }
-  return { repo, force, dryRun, failOn, allowLocalSource, yes };
-}
-
-export async function runInstall(
-  args: string[],
-  options: { isJson: boolean },
-): Promise<void> {
-  const { repo, force, dryRun, failOn, allowLocalSource, yes } = parseInstallArgs(args);
-  if (!repo) {
-    throw new Error(
-      `usage: skillmux install <repo>[/path] [--yes] [--force] [--fail-on ${FAIL_ON_USAGE}] [--dry-run] [--allow-local-source] [--json]`,
-    );
-  }
-
-  const source = resolveRepoSource(repo);
-  if (!allowLocalSource && isLocalFileUrl(source.url)) {
-    throw new Error(
-      `"${repo}" is a local (file://) source — pass --allow-local-source to install from it`,
-    );
-  }
-  const config = await loadConfig();
-  assertHostAllowed(source.url, config.egress?.allowed_hosts);
-  const cloneDir = await cloneToTemp(source.url);
-  try {
-    const resolved = resolveSkillDir(
-      cloneDir,
-      deriveRepoName(source.url),
-      source.skillPath,
-    );
-    const { findings } = await validateSkillCandidate(
-      resolved.skillId,
-      resolved.dir,
-    );
-    if (!options.isJson) console.log(renderScanText({ scanned: 1, findings }));
-
-    // Defaults to blocking on a high-severity finding. Printing the findings
-    // and installing anyway is the wrong default for the command that pulls
-    // remote content into the vault.
-    const effectiveFailOn = resolveMutatingFailOn(failOn);
-    if (scanExitCode(findings, effectiveFailOn) !== 0) {
-      process.exitCode = 1;
-      console.error(
-        `aborting install: a finding met the --fail-on ${effectiveFailOn} threshold` +
-          (failOn === undefined ? " (the default)" : "") +
-          `; re-run with --fail-on none to install anyway`,
-      );
-      return;
-    }
-
-    const vaultPath = expandHome(config.vault_path);
-    if (dryRun) {
-      const plannedPath = join(vaultPath, resolved.skillId);
-      emitSuccess(
-        { isJson: options.isJson },
-        { skill_id: resolved.skillId, would_install_at: plannedPath },
-        () =>
-          console.log(
-            `dry-run: would install "${resolved.skillId}" into ${plannedPath}`,
-          ),
-      );
-      return;
-    }
-
-    // Confirm after the scan, so an interactive user decides with the findings
-    // already on screen, and after the --dry-run return, which writes nothing.
-    const proceed = await confirmIfNeeded({
-      confirmed: yes,
-      isJson: options.isJson,
-      prompt: `install:\n  ${resolved.skillId} <- ${source.url}\n?`,
-      nonInteractiveError: "skillmux install requires --yes when run non-interactively",
-    });
-    if (!proceed) return;
-
-    const commit = resolveCloneCommit(cloneDir);
-    const targetDir = installIntoVault(
-      vaultPath,
-      resolved.skillId,
-      resolved.dir,
-      force,
-    );
-    writeSkillOrigin(targetDir, {
-      source_url: source.url,
-      skill_path: source.skillPath,
-      commit,
-      installed_at: new Date().toISOString(),
-      content_hash: hashSkillContent(targetDir),
-    });
-    emitSuccess(
-      { isJson: options.isJson },
-      { skill_id: resolved.skillId, installed_at: targetDir },
-      () => console.log(`installed "${resolved.skillId}" into ${targetDir}`),
-    );
-  } finally {
-    rmSync(cloneDir, { recursive: true, force: true });
-  }
-}

package/src/commands/local-vault.ts

@@ -1,60 +0,0 @@
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import { expandHome, loadConfig } from "../config";
-import { emitSuccess } from "../output";
-import { writeLocalVaultMarker } from "../sync";
-import { confirmIfNeeded } from "./shared";
-
-export async function runLocalVaultInit(
-  args: string[],
-  options: { isJson: boolean; dryRun: boolean },
-): Promise<void> {
-  const path = args[0];
-  if (!path) throw new Error("usage: skillmux local-vault init <path> --yes");
-  const expanded = expandHome(path);
-  const config = await loadConfig();
-  const localVaultPaths = config.local_vault_paths.map(expandHome);
-  if (!localVaultPaths.includes(expanded)) {
-    throw new Error(
-      `"${path}" is not one of the configured local_vault_paths — add it to config.toml first`,
-    );
-  }
-  if (!existsSync(expanded)) throw new Error(`"${path}" does not exist`);
-  const markerPath = join(expanded, ".skillmux");
-  if (options.dryRun) {
-    emitSuccess(
-      { isJson: options.isJson },
-      {
-        marker_path: markerPath,
-        vault_path: expandHome(config.vault_path),
-      },
-      () =>
-        console.log(
-          `local-vault init: ${markerPath} (role: local_vault, vault_path: ${expandHome(config.vault_path)}) (dry-run)`,
-        ),
-    );
-    return;
-  }
-  if (
-    !(await confirmIfNeeded({
-      confirmed: args.includes("--yes"),
-      isJson: options.isJson,
-      prompt: `mark ${expanded} as a local_vault (role: local_vault, vault_path: ${expandHome(config.vault_path)})?`,
-      nonInteractiveError:
-        "skillmux local-vault init requires --yes when run non-interactively",
-    }))
-  )
-    return;
-  writeLocalVaultMarker(expanded, expandHome(config.vault_path));
-  emitSuccess(
-    { isJson: options.isJson },
-    {
-      marker_path: markerPath,
-      vault_path: expandHome(config.vault_path),
-    },
-    () =>
-      console.log(
-        `wrote ${markerPath} (role: local_vault, vault_path: ${expandHome(config.vault_path)})`,
-      ),
-  );
-}

package/src/commands/models.ts

@@ -1,10 +0,0 @@
-import { loadConfig } from "../config";
-import { downloadLocalModels } from "../models";
-import { emitSuccess } from "../output";
-
-export async function runModelDownload(options: { isJson: boolean }): Promise<void> {
-  const cacheDir = await downloadLocalModels(await loadConfig());
-  emitSuccess({ isJson: options.isJson }, { cache_dir: cacheDir }, () =>
-    console.log(`models ready in ${cacheDir}`),
-  );
-}

package/src/commands/outdated.ts

@@ -1,115 +0,0 @@
-import { readdirSync } from "node:fs";
-import { join } from "node:path";
-import { expandHome, loadConfig } from "../config";
-import { assertHostAllowed, isLocalFileUrl, remoteHeadCommit } from "../install";
-import { emitSuccess } from "../output";
-import { readSkillOrigin } from "../provenance";
-import { SKILL_ID_PATTERN } from "../vault";
-import { isGlobalFlag } from "../global-flags";
-
-export interface OutdatedCheckResult {
-  skill_id: string;
-  source_url: string;
-  recorded_commit: string;
-  remote_commit: string | null;
-  status: "up_to_date" | "outdated" | "check_failed" | "local_source_skipped";
-  reason: string | null;
-}
-
-function vaultSkillIds(vaultPath: string): string[] {
-  return readdirSync(vaultPath, { withFileTypes: true })
-    .filter((entry) => entry.isDirectory() && SKILL_ID_PATTERN.test(entry.name))
-    .map((entry) => entry.name)
-    .sort();
-}
-
-export async function checkOutdated(
-  vaultPath: string,
-  options: { allowLocalSource?: boolean; allowedHosts?: string[] } = {},
-): Promise<OutdatedCheckResult[]> {
-  const results: OutdatedCheckResult[] = [];
-  for (const skillId of vaultSkillIds(vaultPath)) {
-    let origin: ReturnType<typeof readSkillOrigin>;
-    try {
-      origin = readSkillOrigin(join(vaultPath, skillId));
-    } catch (error) {
-      // A corrupt or unreadable sidecar is this skill's problem alone — never
-      // let it abort the check for every other skill in the vault (AC3/AC4's
-      // per-skill isolation applies to local parse failures too, not just
-      // unreachable remotes).
-      results.push({
-        skill_id: skillId,
-        source_url: "",
-        recorded_commit: "",
-        remote_commit: null,
-        status: "check_failed",
-        reason: `.skillmux-origin: ${error instanceof Error ? error.message : String(error)}`,
-      });
-      continue;
-    }
-    if (!origin) continue;
-
-    if (!options.allowLocalSource && isLocalFileUrl(origin.source_url)) {
-      results.push({
-        skill_id: skillId,
-        source_url: origin.source_url,
-        recorded_commit: origin.commit,
-        remote_commit: null,
-        status: "local_source_skipped",
-        reason: "source_url is a local file:// path — skipped by default; pass --allow-local-source to check it",
-      });
-      continue;
-    }
-
-    let remoteCommit: string | null = null;
-    let status: OutdatedCheckResult["status"];
-    let reason: string | null = null;
-    try {
-      assertHostAllowed(origin.source_url, options.allowedHosts);
-      remoteCommit = await remoteHeadCommit(origin.source_url);
-      status = remoteCommit === origin.commit ? "up_to_date" : "outdated";
-    } catch (error) {
-      status = "check_failed";
-      reason = error instanceof Error ? error.message : String(error);
-    }
-
-    results.push({
-      skill_id: skillId,
-      source_url: origin.source_url,
-      recorded_commit: origin.commit,
-      remote_commit: remoteCommit,
-      status,
-      reason,
-    });
-  }
-  return results;
-}
-
-export async function runOutdated(args: string[], options: { isJson: boolean }): Promise<void> {
-  let allowLocalSource = false;
-  for (const arg of args) {
-    if (isGlobalFlag(arg, "--json")) continue;
-    if (arg === "--allow-local-source") {
-      allowLocalSource = true;
-      continue;
-    }
-    throw new Error(`unknown outdated option: ${arg}`);
-  }
-
-  const config = await loadConfig();
-  const vaultPath = expandHome(config.vault_path);
-  const skills = await checkOutdated(vaultPath, { allowLocalSource, allowedHosts: config.egress?.allowed_hosts });
-  const checksFailed = skills.filter((s) => s.status === "check_failed").length;
-  process.exitCode = checksFailed > 0 ? 1 : 0;
-
-  emitSuccess({ isJson: options.isJson }, { skills, checks_failed: checksFailed }, () => {
-    if (skills.length === 0) {
-      console.log("outdated: no vault skills carry provenance");
-      return;
-    }
-    for (const s of skills) {
-      const suffix = s.status === "check_failed" ? ` — ${s.reason}` : "";
-      console.log(`[${s.status}] ${s.skill_id}${suffix}`);
-    }
-  });
-}