avenic 1.0.0

package/src/cli/watchdog.mjs

@@ -0,0 +1,30 @@
+import { spawn } from "node:child_process";
+import { writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { sessionLeasePath } from "#core";
+
+const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+
+// Start the detached watchdog that finishes this launch if the CLI process is
+// killed without a normal exit (closed terminal, closed editor, crash): it
+// captures the run's sessions into the project and restores the native
+// storage. Detached and windowless, so closing the terminal does not kill it.
+// Best-effort: launch continues without it if spawning fails.
+export async function spawnSessionWatchdog(agentId, projectRoot, member, environment) {
+  const stateDir = sessionLeasePath(agentId, projectRoot);
+  await writeFile(
+    path.join(stateDir, "watchdog.json"),
+    JSON.stringify({ member, parentPid: process.pid, agentId, projectRoot, environment }),
+    { encoding: "utf8", mode: 0o600 },
+  );
+  const child = spawn(process.execPath, [path.join(packageRoot, "scripts", "watchdog.mjs"), stateDir], {
+    cwd: os.tmpdir(),
+    detached: true,
+    stdio: "ignore",
+    windowsHide: true,
+  });
+  child.unref();
+  return child;
+}

package/vendor/core-src/index.mjs

@@ -0,0 +1,143 @@
+// Public API of @avenic/core.
+
+export { AGENTS, agentExecutableAvailable, getAgent } from "./runtime/agents.mjs";
+export {
+  clearLocalAuth,
+  deinitializeAgent,
+  effectiveAgentConfig,
+  initializeAgent,
+  loadRuntime,
+  projectAuthEnvironment,
+  runtimePaths,
+  setLocalAuth,
+  validateAuthMode,
+  validateSessionsMode,
+} from "./runtime/config.mjs";
+export {
+  REQUIRED_RULES,
+  SESSIONS_RULE,
+  ensureRuntimeGitignore,
+  removeRuntimeGitignore,
+  sessionsGitIgnored,
+  setSessionsGitIgnored,
+} from "./runtime/gitignore.mjs";
+export { locateProjectRoot } from "./runtime/project-root.mjs";
+export { spawnExecutableSync } from "./runtime/process.mjs";
+export {
+  PROJECT_ROOT_TOKEN,
+  acquireSessionLease,
+  hashContent,
+  listFiles,
+  mergeFiles,
+  processAlive,
+  readFirstJsonLine,
+  releaseSessionLease,
+  replaceDirectory,
+  revertFrom,
+  samePath,
+  sessionLeasePath,
+  snapshotFiles,
+  snapshotInto,
+  transformJsonLines,
+} from "./runtime/sessions.mjs";
+export { getSessionAdapter } from "./runtime/adapters/index.mjs";
+
+export { fail } from "./util/fail.mjs";
+export { isInside, removeEmptyDirectory } from "./util/fs.mjs";
+export { readJson, writeJson } from "./util/json.mjs";
+export {
+  assertSafeId,
+  assertSafeSkillName,
+  assertSafeSkillPath,
+  assertSafeSkillRoot,
+  assertSafeRelativePath,
+} from "./skills/ids.mjs";
+export {
+  GLOBAL_TARGETS,
+  LEGACY_PROFILE_FILE,
+  PROJECT_CONFIG_FILE,
+  PROJECT_LOCK_FILE,
+  PROJECT_TARGETS,
+  catalogCacheRoot,
+  defaultCatalogFile,
+  globalConfigFile,
+  globalLockFile,
+  knownCatalogsFile,
+  stateRoot,
+} from "./skills/paths.mjs";
+export {
+  cloneHead,
+  cloneRevision,
+  currentRepositoryState,
+  deriveSourceId,
+  git,
+  normalizeRepositoryInput,
+  remoteHead,
+  repositoryIdentity,
+  run,
+} from "./skills/git.mjs";
+export {
+  catalogDisplayName,
+  ensureCatalog,
+  loadDefaultCatalogSpec,
+  loadKnownCatalogs,
+  parseCatalogSpec,
+  registerCatalog,
+  registerKnownCatalog,
+  setDefaultCatalogSpec,
+} from "./skills/catalog.mjs";
+export {
+  addDirectSkills,
+  directLicensesRoot,
+  directRoot,
+  readDirectState,
+  removeDirectSkills,
+  removeExternalSkills,
+  writeDirectState,
+} from "./skills/direct.mjs";
+export { printTree } from "./skills/ui.mjs";
+export {
+  buildCatalog,
+  detectSkillRoot,
+  discoverSourceSkills,
+  findSource,
+  loadSources,
+  parseFrontmatterName,
+  readSkill,
+  registerSource,
+  saveSources,
+  stageSource,
+} from "./skills/sources.mjs";
+export {
+  addSkillsToPacks,
+  catalogReferences,
+  loadPacks,
+  normalizePackIds,
+  packContainsSkill,
+  parsePackArguments,
+  pruneCatalogSkills,
+  resolvePack,
+  resolvePacks,
+  skillCoveredByPacks,
+} from "./skills/packs.mjs";
+export {
+  createTempDirectory,
+  removeTempDirectory,
+  replaceStagedFiles,
+} from "./skills/vendor.mjs";
+export {
+  createInstallContext,
+  installCopies,
+  installPacks,
+  installedPackIds,
+  isCatalogDirectory,
+  previousManagedState,
+  removeAllManagedSkills,
+  removeInstallationFiles,
+  removeSkillDirectories,
+  resolveInstallPacks,
+  resolveInstallSource,
+  skillsInstallationStatus,
+  uninstallPacks,
+  writeInstallMetadata,
+} from "./skills/install.mjs";

package/vendor/core-src/runtime/adapters/claude.mjs

@@ -0,0 +1,81 @@
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import { runtimePaths } from "../config.mjs";
+import {
+  PROJECT_ROOT_TOKEN,
+  listFiles,
+  mergeFiles,
+  revertFrom,
+  samePath,
+  snapshotFiles,
+  snapshotInto,
+  transformJsonLines,
+} from "../sessions.mjs";
+
+export function claudeProjectKey(projectRoot) {
+  return path.resolve(projectRoot).replace(/[^a-zA-Z0-9]/g, "-");
+}
+
+function locations(projectRoot, environment = process.env) {
+  const claudeHome = environment.CLAUDE_CONFIG_DIR || path.join(homedir(), ".claude");
+  return {
+    native: path.join(claudeHome, "projects", claudeProjectKey(projectRoot)),
+    portable: path.join(runtimePaths(projectRoot).sessionsRoot, "claude"),
+  };
+}
+
+function rewriteCwd(content, projectRoot, restore) {
+  return transformJsonLines(content.toString("utf8"), (record) => {
+    if (restore ? typeof record.cwd === "string" : samePath(record.cwd, projectRoot)) {
+      record.cwd = restore ? projectRoot : PROJECT_ROOT_TOKEN;
+    }
+    return record;
+  });
+}
+
+export async function capture(projectRoot, options = {}) {
+  const { native, portable } = locations(projectRoot, options.environment);
+  const files = await listFiles(native);
+  if (files.length === 0) {
+    return { count: 0, changed: false };
+  }
+  await snapshotFiles(native, files, portable, (content, relative) =>
+    relative.endsWith(".jsonl") ? rewriteCwd(content, projectRoot, false) : content,
+  );
+  return { count: files.filter((file) => file.endsWith(".jsonl") && !file.includes(`${path.sep}subagents${path.sep}`)).length, changed: true };
+}
+
+export async function restore(projectRoot, options = {}) {
+  const { native, portable } = locations(projectRoot, options.environment);
+  const files = await listFiles(portable);
+  if (files.length === 0) {
+    return { count: 0, added: 0, updated: 0, unchanged: 0 };
+  }
+  // Project portable sessions are the source of truth: on conflict they
+  // overwrite the native copy (explicit `sessions writeback` semantics).
+  const result = await mergeFiles(portable, files, native, (content, relative) =>
+    relative.endsWith(".jsonl") ? rewriteCwd(content, projectRoot, true) : content,
+    { onConflict: "keep-source" },
+  );
+  return { count: files.length, ...result };
+}
+
+export async function status(projectRoot) {
+  const { portable } = locations(projectRoot);
+  const files = await listFiles(portable);
+  return { count: files.filter((file) => file.endsWith(".jsonl") && !file.includes(`${path.sep}subagents${path.sep}`)).length };
+}
+
+// Save the native project directory into the shared launch state so the last
+// exit can restore it: sessions created by `avenic claude` must live only
+// in the project, never in the global native storage.
+export async function snapshotNative(projectRoot, snapshotRoot, options = {}) {
+  const { native } = locations(projectRoot, options.environment);
+  await snapshotInto(native, snapshotRoot);
+}
+
+export async function revertNative(snapshotRoot, projectRoot, options = {}) {
+  const { native } = locations(projectRoot, options.environment);
+  await revertFrom(snapshotRoot, native);
+}

package/vendor/core-src/runtime/adapters/codex.mjs

@@ -0,0 +1,142 @@
+import { existsSync } from "node:fs";
+import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { runtimePaths } from "../config.mjs";
+import {
+  PROJECT_ROOT_TOKEN,
+  listFiles,
+  mergeFiles,
+  readFirstJsonLine,
+  replaceDirectory,
+  revertFrom,
+  samePath,
+  snapshotInto,
+  transformJsonLines,
+} from "../sessions.mjs";
+
+function locations(projectRoot, environment = process.env) {
+  const codexHome = environment.CODEX_HOME || path.join(homedir(), ".codex");
+  return {
+    codexHome,
+    nativeSessions: path.join(codexHome, "sessions"),
+    portable: path.join(runtimePaths(projectRoot).sessionsRoot, "codex"),
+  };
+}
+
+function rewriteCwd(content, projectRoot, restore) {
+  return transformJsonLines(content.toString("utf8"), (record) => {
+    const cwd = record.payload?.cwd;
+    if (restore ? typeof cwd === "string" : samePath(cwd, projectRoot)) {
+      record.payload.cwd = restore ? projectRoot : PROJECT_ROOT_TOKEN;
+    }
+    return record;
+  });
+}
+
+async function matchingRollouts(root, projectRoot) {
+  const matches = [];
+  for (const relative of await listFiles(root)) {
+    if (!relative.endsWith(".jsonl")) {
+      continue;
+    }
+    try {
+      const first = await readFirstJsonLine(path.join(root, relative));
+      if (first.type === "session_meta" && samePath(first.payload?.cwd, projectRoot)) {
+        matches.push({ relative, id: first.payload?.id ?? first.payload?.session_id });
+      }
+    } catch {}
+  }
+  return matches;
+}
+
+async function filteredIndex(codexHome, ids) {
+  const indexFile = path.join(codexHome, "session_index.jsonl");
+  if (!existsSync(indexFile)) {
+    return "";
+  }
+  return (await readFile(indexFile, "utf8"))
+    .split(/\r?\n/)
+    .filter((line) => {
+      if (!line.trim()) return false;
+      try {
+        return ids.has(JSON.parse(line).id);
+      } catch {
+        return false;
+      }
+    })
+    .join("\n");
+}
+
+export async function capture(projectRoot, options = {}) {
+  const { codexHome, nativeSessions, portable } = locations(projectRoot, options.environment);
+  const rollouts = await matchingRollouts(nativeSessions, projectRoot);
+  if (rollouts.length === 0) {
+    return { count: 0, changed: false };
+  }
+  const ids = new Set(rollouts.map(({ id }) => id).filter(Boolean));
+  await replaceDirectory(portable, async (temporary) => {
+    for (const { relative } of rollouts) {
+      const target = path.join(temporary, "sessions", relative);
+      await mkdir(path.dirname(target), { recursive: true });
+      await writeFile(target, rewriteCwd(await readFile(path.join(nativeSessions, relative)), projectRoot, false));
+    }
+    const index = await filteredIndex(codexHome, ids);
+    if (index) {
+      await writeFile(path.join(temporary, "session_index.jsonl"), `${index}\n`, "utf8");
+    }
+  });
+  return { count: rollouts.length, changed: true };
+}
+
+async function restoreIndex(portable, codexHome) {
+  const source = path.join(portable, "session_index.jsonl");
+  if (!existsSync(source)) {
+    return;
+  }
+  const destination = path.join(codexHome, "session_index.jsonl");
+  const existing = existsSync(destination) ? await readFile(destination, "utf8") : "";
+  const existingLines = new Set(existing.split(/\r?\n/).filter(Boolean));
+  const additions = (await readFile(source, "utf8")).split(/\r?\n/).filter((line) => line && !existingLines.has(line));
+  if (additions.length > 0) {
+    await mkdir(codexHome, { recursive: true });
+    await appendFile(destination, `${existing && !existing.endsWith("\n") ? "\n" : ""}${additions.join("\n")}\n`, "utf8");
+  }
+}
+
+export async function restore(projectRoot, options = {}) {
+  const { codexHome, nativeSessions, portable } = locations(projectRoot, options.environment);
+  const sourceRoot = path.join(portable, "sessions");
+  const files = await listFiles(sourceRoot);
+  if (files.length === 0) {
+    return { count: 0, added: 0, updated: 0, unchanged: 0 };
+  }
+  // Project portable sessions are the source of truth: on conflict they
+  // overwrite the native copy (explicit `sessions writeback` semantics).
+  const result = await mergeFiles(sourceRoot, files, nativeSessions, (content, relative) =>
+    relative.endsWith(".jsonl") ? rewriteCwd(content, projectRoot, true) : content,
+    { onConflict: "keep-source" },
+  );
+  await restoreIndex(portable, codexHome);
+  return { count: files.length, ...result };
+}
+
+export async function status(projectRoot) {
+  const { portable } = locations(projectRoot);
+  return { count: (await listFiles(path.join(portable, "sessions"))).filter((file) => file.endsWith(".jsonl")).length };
+}
+
+// Save the native sessions directory and session index into the shared launch
+// state so the last exit can restore them: sessions created by `avenic
+// codex` must live only in the project, never in the global native storage.
+export async function snapshotNative(projectRoot, snapshotRoot, options = {}) {
+  const { codexHome, nativeSessions } = locations(projectRoot, options.environment);
+  await snapshotInto(nativeSessions, path.join(snapshotRoot, "sessions"));
+  await snapshotInto(path.join(codexHome, "session_index.jsonl"), path.join(snapshotRoot, "index.jsonl"));
+}
+
+export async function revertNative(snapshotRoot, projectRoot, options = {}) {
+  const { codexHome, nativeSessions } = locations(projectRoot, options.environment);
+  await revertFrom(path.join(snapshotRoot, "index.jsonl"), path.join(codexHome, "session_index.jsonl"));
+  await revertFrom(path.join(snapshotRoot, "sessions"), nativeSessions);
+}

package/vendor/core-src/runtime/adapters/index.mjs

@@ -0,0 +1,9 @@
+import * as claude from "./claude.mjs";
+import * as codex from "./codex.mjs";
+import * as opencode from "./opencode.mjs";
+
+const ADAPTERS = { claude, codex, opencode };
+
+export function getSessionAdapter(agentId) {
+  return ADAPTERS[agentId];
+}

package/vendor/core-src/runtime/adapters/opencode.mjs

@@ -0,0 +1,76 @@
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { runtimePaths } from "../config.mjs";
+import { hashContent, listFiles, replaceDirectory, samePath } from "../sessions.mjs";
+import { spawnExecutableSync } from "../process.mjs";
+
+function run(argumentsList, projectRoot, options = {}) {
+  const result = spawnExecutableSync("opencode", argumentsList, {
+    cwd: projectRoot,
+    encoding: "utf8",
+    env: options.environment ?? process.env,
+    windowsHide: true,
+    spawn: options.spawn,
+  });
+  if (result.error) {
+    throw new Error(`Unable to launch opencode: ${result.error.message}`);
+  }
+  if (result.status !== 0) {
+    throw new Error(result.stderr?.trim() || `opencode exited with code ${result.status}`);
+  }
+  return result.stdout;
+}
+
+function portableRoot(projectRoot) {
+  return path.join(runtimePaths(projectRoot).sessionsRoot, "opencode");
+}
+
+function matchingSessions(projectRoot, options) {
+  const sessions = JSON.parse(run(["session", "list", "--format", "json"], projectRoot, options));
+  return sessions.filter((session) => samePath(session.directory, projectRoot));
+}
+
+export async function capture(projectRoot, options = {}) {
+  const sessions = matchingSessions(projectRoot, options);
+  if (sessions.length === 0) {
+    return { count: 0, changed: false };
+  }
+  await replaceDirectory(portableRoot(projectRoot), async (temporary) => {
+    for (const session of sessions) {
+      await writeFile(path.join(temporary, `${session.id}.json`), run(["export", session.id], projectRoot, options), "utf8");
+    }
+  });
+  return { count: sessions.length, changed: true };
+}
+
+export async function restore(projectRoot, options = {}) {
+  const portable = portableRoot(projectRoot);
+  const files = (await listFiles(portable)).filter((file) => file.endsWith(".json"));
+  if (files.length === 0) {
+    return { count: 0, added: 0, updated: 0, unchanged: 0 };
+  }
+  const localRoot = path.join(runtimePaths(projectRoot).localRoot, "opencode");
+  const manifestFile = path.join(localRoot, "session-imports.json");
+  const manifest = existsSync(manifestFile) ? JSON.parse(await readFile(manifestFile, "utf8")) : {};
+  let imported = 0;
+  let unchanged = 0;
+  for (const relative of files) {
+    const file = path.join(portable, relative);
+    const hash = hashContent(await readFile(file));
+    if (manifest[relative] === hash) {
+      unchanged += 1;
+      continue;
+    }
+    run(["import", file], projectRoot, options);
+    manifest[relative] = hash;
+    imported += 1;
+  }
+  await mkdir(localRoot, { recursive: true });
+  await writeFile(manifestFile, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+  return { count: files.length, added: imported, updated: 0, unchanged };
+}
+
+export async function status(projectRoot) {
+  return { count: (await listFiles(portableRoot(projectRoot))).filter((file) => file.endsWith(".json")).length };
+}

package/vendor/core-src/runtime/agents.mjs

@@ -0,0 +1,39 @@
+import process from "node:process";
+import { spawnExecutableSync } from "./process.mjs";
+
+export const AGENTS = {
+  claude: {
+    displayName: "Claude Code",
+    executable: "claude",
+  },
+  codex: {
+    displayName: "Codex",
+    executable: "codex",
+  },
+  opencode: {
+    displayName: "OpenCode",
+    executable: "opencode",
+  },
+};
+
+export function getAgent(agentId) {
+  const agent = AGENTS[agentId];
+  if (!agent) {
+    throw new Error(`Unknown Agent: ${agentId}`);
+  }
+  return { id: agentId, ...agent };
+}
+
+export function agentExecutableAvailable(agentId, environment = process.env) {
+  const agent = getAgent(agentId);
+  try {
+    const result = spawnExecutableSync(agent.executable, ["--version"], {
+      env: environment,
+      stdio: "pipe",
+      windowsHide: true,
+    });
+    return result.status === 0;
+  } catch {
+    return false;
+  }
+}