@evo-dev/evodev 0.0.1-alpha → 0.0.1-alpha.1

package/dist/plugins/evodev/hooks/plugin.ts

@@ -23,6 +23,11 @@ import {
 } from "./paths.ts";
 import { transformClaudeAgent } from "./transform-agent.ts";
 import { transformClaudeSkill } from "./transform-skill.ts";
+import {
+  type WorkspaceCoreHydrationResult,
+  hydrateWorkspaceCoreDependency,
+  isSafePluginCacheSegment,
+} from "./workspace-core.ts";
 
 export interface ClaudePathAccessResult {
   exists: boolean;
@@ -37,7 +42,7 @@ export interface ClaudePathAccess {
 
 export interface ClaudeSyncFileSystem {
   readFile(path: string): Promise<string>;
-  writeFile(path: string, content: string): Promise<void>;
+  writeFile(path: string, content: string, options?: { overwrite?: boolean }): Promise<void>;
   fileExists(path: string): Promise<boolean>;
   ensureDir(path: string): Promise<void>;
 }
@@ -142,8 +147,15 @@ const nodeSyncFileSystem: ClaudeSyncFileSystem = {
   async readFile(path: string): Promise<string> {
     return readFile(path, "utf8");
   },
-  async writeFile(path: string, content: string): Promise<void> {
-    await writeFile(path, content, { encoding: "utf8", flag: "wx" });
+  async writeFile(
+    path: string,
+    content: string,
+    options: { overwrite?: boolean } = {},
+  ): Promise<void> {
+    await writeFile(path, content, {
+      encoding: "utf8",
+      flag: options.overwrite === true ? "w" : "wx",
+    });
   },
   async fileExists(path: string): Promise<boolean> {
     try {
@@ -174,7 +186,7 @@ async function installClaudeCodePlugin(
   input: PluginInstallInput,
   options: Pick<
     ClaudePluginOptions,
-    "commandRunner" | "pluginSelector" | "pluginMarketplaceSource" | "pluginScope"
+    "commandRunner" | "paths" | "pluginSelector" | "pluginMarketplaceSource" | "pluginScope"
   >,
 ): Promise<PluginInstallResult> {
   const command = "claude";
@@ -182,6 +194,7 @@ async function installClaudeCodePlugin(
   const scope = options.pluginScope ?? "user";
   const args = ["plugin", "install", selector, "--scope", scope];
   const runner = options.commandRunner ?? new NodeClaudeCommandRunner();
+  const warnings: string[] = [];
 
   try {
     if (options.pluginMarketplaceSource !== undefined) {
@@ -204,10 +217,73 @@ async function installClaudeCodePlugin(
             `Claude Code marketplace add exited with code ${marketplaceResult.exitCode}`,
         );
       }
+
+      const marketplaceName = extractMarketplaceNameFromSelector(selector);
+      if (marketplaceName === undefined) {
+        warnings.push(
+          `Skipped Claude Code marketplace update because selector does not include a marketplace name: ${selector}`,
+        );
+      } else {
+        const updateResult = await runner.run(command, [
+          "plugin",
+          "marketplace",
+          "update",
+          marketplaceName,
+        ]);
+        if (updateResult.exitCode !== 0) {
+          return createPluginInstallResult(
+            input.targetPlugin,
+            "failed",
+            command,
+            args,
+            updateResult.stderr ??
+              updateResult.stdout ??
+              `Claude Code marketplace update exited with code ${updateResult.exitCode}`,
+          );
+        }
+      }
+    }
+
+    if (input.force === true) {
+      const uninstallArgs = [
+        "plugin",
+        "uninstall",
+        selector,
+        "--scope",
+        scope,
+        "--keep-data",
+        "-y",
+      ];
+      const uninstallResult = await runner.run(command, uninstallArgs);
+      const uninstallMessage = uninstallResult.stderr ?? uninstallResult.stdout;
+      if (uninstallResult.exitCode !== 0 && !isNotInstalledMessage(uninstallMessage)) {
+        warnings.push(
+          `Claude Code plugin refresh uninstall did not complete: ${
+            uninstallMessage ??
+            `Claude Code plugin uninstall exited with code ${uninstallResult.exitCode}`
+          }`,
+        );
+      }
     }
 
     const result = await runner.run(command, args);
     if (result.exitCode === 0) {
+      const hydration = await hydrateClaudeWorkspaceCoreDependency({
+        paths: options.paths,
+        selector,
+      });
+      warnings.push(...hydration.warnings);
+      if (hydration.errors.length > 0) {
+        return createPluginInstallResult(
+          input.targetPlugin,
+          "failed",
+          command,
+          args,
+          hydration.errors.join("\n"),
+          warnings,
+        );
+      }
+
       if (isAlreadyInstalledMessage(result.stdout ?? result.stderr)) {
         return createPluginInstallResult(
           input.targetPlugin,
@@ -216,7 +292,10 @@ async function installClaudeCodePlugin(
           args,
           result.stdout,
           [
-            "Claude Code reported the plugin is already installed; if local plugin files changed without a version bump, Claude may keep the existing cached copy. Bump the plugin version or uninstall and reinstall to refresh the cache.",
+            ...warnings,
+            input.force === true
+              ? "Claude Code reported the plugin is already installed after forced refresh; check the local plugin cache if changes are not visible."
+              : "Claude Code reported the plugin is already installed; if local plugin files changed without a version bump, Claude may keep the existing cached copy. Bump the plugin version or uninstall and reinstall to refresh the cache.",
           ],
         );
       }
@@ -227,6 +306,7 @@ async function installClaudeCodePlugin(
         command,
         args,
         result.stdout,
+        warnings,
       );
     }
 
@@ -254,6 +334,61 @@ function isAlreadyInstalledMessage(message: string | undefined): boolean {
   return message !== undefined && /already\s+installed/i.test(message);
 }
 
+function isNotInstalledMessage(message: string | undefined): boolean {
+  return message !== undefined && /(not\s+installed|not\s+found|no\s+installed)/i.test(message);
+}
+
+function extractMarketplaceNameFromSelector(selector: string): string | undefined {
+  const separator = selector.lastIndexOf("@");
+  if (separator <= 0 || separator === selector.length - 1) return undefined;
+  return selector.slice(separator + 1);
+}
+
+function extractPluginNameFromSelector(selector: string): string | undefined {
+  const separator = selector.lastIndexOf("@");
+  const pluginName = separator <= 0 ? selector : selector.slice(0, separator);
+  return pluginName.trim() === "" ? undefined : pluginName;
+}
+
+async function hydrateClaudeWorkspaceCoreDependency(input: {
+  paths?: ClaudePaths;
+  selector: string;
+}): Promise<WorkspaceCoreHydrationResult> {
+  const warnings: string[] = [];
+  const errors: string[] = [];
+
+  if (input.paths === undefined) {
+    return { warnings, errors };
+  }
+
+  const marketplaceName = extractMarketplaceNameFromSelector(input.selector);
+  const pluginName = extractPluginNameFromSelector(input.selector);
+  if (marketplaceName === undefined || pluginName === undefined) {
+    warnings.push(
+      `Skipped @evo-dev/core hydration because Claude plugin selector is not marketplace-qualified: ${input.selector}`,
+    );
+    return { warnings, errors };
+  }
+  if (!isSafePluginCacheSegment(marketplaceName) || !isSafePluginCacheSegment(pluginName)) {
+    warnings.push(
+      `Skipped @evo-dev/core hydration because Claude plugin selector contains an unsafe cache segment: ${input.selector}`,
+    );
+    return { warnings, errors };
+  }
+
+  const cachePluginRoot = `${input.paths.claudeDir}/plugins/cache/${marketplaceName}/${pluginName}`;
+  const marketplaceCoreRoot = `${input.paths.claudeDir}/plugins/marketplaces/${marketplaceName}/packages/core`;
+  const hydration = await hydrateWorkspaceCoreDependency({
+    sourceCoreRoot: marketplaceCoreRoot,
+    cachePluginRoot,
+    runtimeLabel: "Claude",
+  });
+  return {
+    warnings: [...warnings, ...hydration.warnings],
+    errors: [...errors, ...hydration.errors],
+  };
+}
+
 class NodeClaudeCommandRunner implements ClaudeCommandRunner {
   async run(
     command: string,
@@ -384,8 +519,9 @@ async function syncClaudeSkills(
       const source = await fileSystem.readFile(asset.entryPath);
       const transformed = transformClaudeSkill({ asset, source });
       const targetPath = resolveClaudeSkillTargetPath(transformed.name, paths);
+      const targetExists = await fileSystem.fileExists(targetPath);
 
-      if (await fileSystem.fileExists(targetPath)) {
+      if (targetExists && input.force !== true) {
         result.skipped.push(asset.registryKey);
         result.warnings.push(`Skipped existing Claude skill target: ${targetPath}`);
         continue;
@@ -393,9 +529,16 @@ async function syncClaudeSkills(
 
       if (!input.dryRun) {
         await fileSystem.ensureDir(dirname(targetPath));
-        await fileSystem.writeFile(targetPath, ensureTrailingNewline(transformed.content));
+        await fileSystem.writeFile(targetPath, ensureTrailingNewline(transformed.content), {
+          overwrite: input.force === true,
+        });
       }
 
+      if (targetExists) {
+        result.warnings.push(
+          `${input.dryRun ? "Would update" : "Updated"} existing Claude skill target: ${targetPath}`,
+        );
+      }
       result.syncedSkills.push(asset.registryKey);
     } catch (error) {
       result.errors.push(
@@ -424,8 +567,9 @@ async function syncClaudeAgents(
       const source = await fileSystem.readFile(asset.entryPath);
       const transformed = transformClaudeAgent({ asset, source });
       const targetPath = resolveClaudeAgentTargetPath(transformed.name, paths);
+      const targetExists = await fileSystem.fileExists(targetPath);
 
-      if (await fileSystem.fileExists(targetPath)) {
+      if (targetExists && input.force !== true) {
         result.skipped.push(asset.registryKey);
         result.warnings.push(`Skipped existing Claude agent target: ${targetPath}`);
         continue;
@@ -433,9 +577,16 @@ async function syncClaudeAgents(
 
       if (!input.dryRun) {
         await fileSystem.ensureDir(dirname(targetPath));
-        await fileSystem.writeFile(targetPath, ensureTrailingNewline(transformed.content));
+        await fileSystem.writeFile(targetPath, ensureTrailingNewline(transformed.content), {
+          overwrite: input.force === true,
+        });
       }
 
+      if (targetExists) {
+        result.warnings.push(
+          `${input.dryRun ? "Would update" : "Updated"} existing Claude agent target: ${targetPath}`,
+        );
+      }
       result.syncedAgents.push(asset.registryKey);
     } catch (error) {
       result.errors.push(

package/dist/plugins/evodev/hooks/runtime.ts

@@ -1,15 +1,21 @@
 #!/usr/bin/env bun
 
 import {
+  type HookEventV1,
+  type HookRuntimeResult,
+  appendTraceLogEntry,
   createCoreConfigStore,
   createDefaultSettings,
+  createTraceLogEntry,
   formatHookRuntimeOutput,
   handleHookRuntime,
+  resolveTraceTeamContext,
 } from "@evo-dev/core";
 import { normalizeClaudeRuntimeHookPayload, normalizeCodexRuntimeHookPayload } from "./hooks.ts";
 
 export interface HookRuntimeCliOptions {
   argv?: string[];
+  environment?: Record<string, string | undefined>;
   homeDir?: string;
   stdin?: string | (() => Promise<string>);
   write?: (message: string) => void;
@@ -17,41 +23,89 @@ export interface HookRuntimeCliOptions {
 
 export async function runHookRuntimeCli(options: HookRuntimeCliOptions = {}): Promise<number> {
   const argv = options.argv ?? process.argv.slice(2);
+  const environment = options.environment ?? process.env;
   const write = options.write ?? process.stdout.write.bind(process.stdout);
+  const startedAt = new Date();
+  let homeDir = options.homeDir ?? process.env.HOME ?? "~";
+  let target = "unknown";
+  let payload: Record<string, unknown> | null = null;
+  let stdinBytes: number | null = null;
 
-  if (argv[0] !== "hook" || argv[1] !== "runtime") {
-    throw new Error(`Unknown plugin command: ${argv.join(" ")}`.trim());
-  }
+  try {
+    if (argv[0] !== "hook" || argv[1] !== "runtime") {
+      throw new Error(`Unknown plugin command: ${argv.join(" ")}`.trim());
+    }
 
-  const flags = parseHookRuntimeFlags(argv.slice(2));
-  if (flags.target !== "claude" && flags.target !== "codex") {
-    throw new Error(`Unsupported hook target: ${flags.target}`);
-  }
+    const flags = parseHookRuntimeFlags(argv.slice(2));
+    target = flags.target;
+    if (flags.target !== "claude" && flags.target !== "codex") {
+      throw new Error(`Unsupported hook target: ${flags.target}`);
+    }
+
+    homeDir = options.homeDir ?? process.env.HOME ?? "~";
+    const stdin = await readHookRuntimeStdin(options.stdin);
+    stdinBytes = Buffer.byteLength(stdin, "utf8");
+    payload = JSON.parse(stdin) as Record<string, unknown>;
+    await appendTraceLogSafely({
+      homeDir,
+      phase: "started",
+      target,
+      argv,
+      payload,
+      stdinBytes,
+      environment,
+    });
 
-  const homeDir = options.homeDir ?? process.env.HOME ?? "~";
-  const payload = JSON.parse(await readHookRuntimeStdin(options.stdin)) as Record<string, unknown>;
-  const settings = await readHookSettings(homeDir);
-  const event =
-    flags.target === "codex"
-      ? normalizeCodexRuntimeHookPayload({
-          payload,
-          receivedAt: new Date().toISOString(),
-        })
-      : normalizeClaudeRuntimeHookPayload({
-          payload,
-          receivedAt: new Date().toISOString(),
-        });
-  const result = await handleHookRuntime({
-    target: flags.target,
-    homeDir,
-    settings: settings.hooks,
-    event,
-    rawPayload: payload,
-    receivedAt: event.time.receivedAt,
-  });
-  const formatted = formatHookRuntimeOutput(result);
-  if (formatted.length > 0) write(formatted);
-  return 0;
+    const settings = await readHookSettings(homeDir);
+    const event =
+      flags.target === "codex"
+        ? normalizeCodexRuntimeHookPayload({
+            payload,
+            receivedAt: new Date().toISOString(),
+          })
+        : normalizeClaudeRuntimeHookPayload({
+            payload,
+            receivedAt: new Date().toISOString(),
+          });
+    const result = await handleHookRuntime({
+      target: flags.target,
+      homeDir,
+      settings: settings.hooks,
+      event,
+      rawPayload: payload,
+      receivedAt: event.time.receivedAt,
+      environment,
+    });
+    const formatted = formatHookRuntimeOutput(result);
+    await appendTraceLogSafely({
+      homeDir,
+      phase: "completed",
+      target,
+      argv,
+      payload,
+      stdinBytes,
+      event,
+      result,
+      formatted,
+      environment,
+      durationMs: Date.now() - startedAt.getTime(),
+    });
+    if (formatted.length > 0) write(formatted);
+    return 0;
+  } catch (error) {
+    await appendTraceLogSafely({
+      homeDir,
+      phase: "failed",
+      target,
+      argv,
+      payload,
+      stdinBytes,
+      error,
+      environment,
+      durationMs: Date.now() - startedAt.getTime(),
+    });
+    throw error;
+  }
 }
 
 function parseHookRuntimeFlags(argv: string[]): { target: string } {
@@ -95,6 +149,67 @@ async function readHookSettings(homeDir: string) {
   }
 }
 
+async function appendTraceLogSafely(input: {
+  homeDir: string;
+  phase: "started" | "completed" | "failed";
+  target: string;
+  argv: string[];
+  payload: Record<string, unknown> | null;
+  stdinBytes: number | null;
+  event?: HookEventV1;
+  result?: HookRuntimeResult;
+  formatted?: string;
+  durationMs?: number | null;
+  error?: unknown;
+  environment?: Record<string, string | undefined>;
+}): Promise<void> {
+  try {
+    await appendTraceLogEntry(
+      input.homeDir,
+      createTraceLogEntry({
+        phase: input.phase,
+        target: input.target,
+        runtime: {
+          surface: "plugin",
+          argv: input.argv,
+          runtimeFile: import.meta.url,
+        },
+        payload: input.payload,
+        stdinBytes: input.stdinBytes,
+        team: resolveTraceTeamContext({
+          homeDir: input.homeDir,
+          environment: input.environment,
+          payload: input.payload,
+        }),
+        event:
+          input.event === undefined
+            ? null
+            : {
+                eventId: input.event.eventId,
+                type: input.event.type,
+                summary: input.event.payload.summary,
+                metadata: input.event.payload.metadata,
+                decision: input.event.decision,
+              },
+        result:
+          input.result === undefined
+            ? null
+            : {
+                enabled: input.result.enabled,
+                summary: input.result.summary,
+                stateWrites: input.result.stateWrites,
+                warnings: input.result.warnings,
+                formattedResponse: input.formatted?.trim() || null,
+                durationMs: input.durationMs ?? null,
+              },
+        error: input.error,
+      }),
+    );
+  } catch {
+    // Trace logging must never change hook runtime behavior.
+  }
+}
+
 function isNotFoundError(error: unknown): boolean {
   return (
     error instanceof Error &&

package/dist/plugins/evodev/hooks/transform-agent.ts

@@ -10,6 +10,16 @@ export interface ClaudeAgentTransformResult {
   content: string;
 }
 
+export interface CodexAgentTransformInput {
+  asset: ScannedAsset<AgentManifest>;
+  source: string;
+}
+
+export interface CodexAgentTransformResult {
+  name: string;
+  content: string;
+}
+
 export function transformClaudeAgent(input: ClaudeAgentTransformInput): ClaudeAgentTransformResult {
   const { manifest } = input.asset;
   const frontmatter = [
@@ -25,6 +35,26 @@ export function transformClaudeAgent(input: ClaudeAgentTransformInput): ClaudeAg
   };
 }
 
+export function transformCodexAgent(input: CodexAgentTransformInput): CodexAgentTransformResult {
+  const { manifest } = input.asset;
+  const lines = [
+    `# Generated by EvoDev from ${input.asset.registryKey}`,
+    `name = ${tomlString(manifest.id)}`,
+    `description = ${tomlString(manifest.description)}`,
+    `developer_instructions = ${tomlString(input.source)}`,
+    "",
+  ];
+
+  return {
+    name: manifest.id,
+    content: lines.join("\n"),
+  };
+}
+
 function escapeFrontmatterValue(value: string): string {
   return value.replaceAll("\n", " ");
 }
+
+function tomlString(value: string): string {
+  return JSON.stringify(value);
+}

package/dist/plugins/evodev/hooks/workspace-core.ts

@@ -0,0 +1,181 @@
+import type { Dirent } from "node:fs";
+import { cp, mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+
+export interface WorkspaceCoreHydrationResult {
+  warnings: string[];
+  errors: string[];
+}
+
+export async function hydrateWorkspaceCoreDependency(input: {
+  sourceCoreRoot: string;
+  cachePluginRoot: string;
+  runtimeLabel: string;
+}): Promise<WorkspaceCoreHydrationResult> {
+  const warnings: string[] = [];
+  const errors: string[] = [];
+
+  const installedPluginRoot = await findInstalledPluginRoot(input.cachePluginRoot);
+  if (installedPluginRoot === null) {
+    warnings.push(
+      `Skipped @evo-dev/core hydration because the ${input.runtimeLabel} plugin cache was not found: ${input.cachePluginRoot}`,
+    );
+    return { warnings, errors };
+  }
+
+  if (!(await isDirectory(input.sourceCoreRoot))) {
+    errors.push(
+      `Cannot hydrate @evo-dev/core for ${input.runtimeLabel} plugin runtime: marketplace core package not found at ${input.sourceCoreRoot}`,
+    );
+    return { warnings, errors };
+  }
+
+  try {
+    await writeRuntimeCorePackage({
+      sourceCoreRoot: input.sourceCoreRoot,
+      targetCoreRoot: `${installedPluginRoot}/node_modules/@evo-dev/core`,
+    });
+  } catch (error) {
+    errors.push(
+      `Cannot hydrate @evo-dev/core for ${input.runtimeLabel} plugin runtime: ${describeError(error)}`,
+    );
+  }
+
+  return { warnings, errors };
+}
+
+export function isSafePluginCacheSegment(segment: string): boolean {
+  return /^[A-Za-z0-9._-]+$/.test(segment) && segment !== "." && segment !== "..";
+}
+
+async function findInstalledPluginRoot(cachePluginRoot: string): Promise<string | null> {
+  let entries: Dirent[];
+  try {
+    entries = await readdir(cachePluginRoot, { withFileTypes: true });
+  } catch (error) {
+    if (isNotFoundError(error)) {
+      return null;
+    }
+    throw error;
+  }
+
+  const versionDirs = await Promise.all(
+    entries
+      .filter((entry) => entry.isDirectory())
+      .map(async (entry) => {
+        const path = `${cachePluginRoot}/${entry.name}`;
+        const pathStat = await stat(path);
+        return { path, mtimeMs: pathStat.mtimeMs };
+      }),
+  );
+  if (versionDirs.length === 0) {
+    return null;
+  }
+
+  versionDirs.sort(
+    (left, right) => right.mtimeMs - left.mtimeMs || right.path.localeCompare(left.path),
+  );
+  return versionDirs[0].path;
+}
+
+async function writeRuntimeCorePackage(input: {
+  sourceCoreRoot: string;
+  targetCoreRoot: string;
+}): Promise<void> {
+  const sourcePackagePath = `${input.sourceCoreRoot}/package.json`;
+  if (!(await isFile(sourcePackagePath))) {
+    throw new Error(`source package.json not found at ${sourcePackagePath}`);
+  }
+  if (!(await isDirectory(`${input.sourceCoreRoot}/src`))) {
+    throw new Error(`source src directory not found at ${input.sourceCoreRoot}/src`);
+  }
+
+  await rm(input.targetCoreRoot, { recursive: true, force: true });
+  await mkdir(dirname(input.targetCoreRoot), { recursive: true });
+  await mkdir(input.targetCoreRoot, { recursive: true });
+  await cp(`${input.sourceCoreRoot}/src`, `${input.targetCoreRoot}/src`, {
+    recursive: true,
+  });
+  if (await isDirectory(`${input.sourceCoreRoot}/assets`)) {
+    await cp(`${input.sourceCoreRoot}/assets`, `${input.targetCoreRoot}/assets`, {
+      recursive: true,
+    });
+  }
+
+  const sourcePackageJson = JSON.parse(await readFile(sourcePackagePath, "utf8")) as Record<
+    string,
+    unknown
+  >;
+  const runtimePackageJson = {
+    ...sourcePackageJson,
+    exports: rewritePackageExportsToSource(sourcePackageJson.exports),
+    files: ["src", "assets", "package.json"],
+  };
+  await writeFile(
+    `${input.targetCoreRoot}/package.json`,
+    `${JSON.stringify(runtimePackageJson, null, 2)}\n`,
+    "utf8",
+  );
+}
+
+function rewritePackageExportsToSource(exportsValue: unknown): unknown {
+  if (typeof exportsValue === "string") {
+    return rewriteDistPathToSource(exportsValue);
+  }
+  if (Array.isArray(exportsValue)) {
+    return exportsValue.map((value) => rewritePackageExportsToSource(value));
+  }
+  if (exportsValue !== null && typeof exportsValue === "object") {
+    return Object.fromEntries(
+      Object.entries(exportsValue).map(([key, value]) => [
+        key,
+        rewritePackageExportsToSource(value),
+      ]),
+    );
+  }
+  return exportsValue;
+}
+
+function rewriteDistPathToSource(path: string): string {
+  if (!path.startsWith("./dist/") || !path.endsWith(".js")) {
+    return path;
+  }
+
+  return `./src/${path.slice("./dist/".length, -".js".length)}.ts`;
+}
+
+async function isDirectory(path: string): Promise<boolean> {
+  try {
+    return (await stat(path)).isDirectory();
+  } catch (error) {
+    if (isNotFoundError(error)) {
+      return false;
+    }
+    throw error;
+  }
+}
+
+async function isFile(path: string): Promise<boolean> {
+  try {
+    return (await stat(path)).isFile();
+  } catch (error) {
+    if (isNotFoundError(error)) {
+      return false;
+    }
+    throw error;
+  }
+}
+
+function isNotFoundError(error: unknown): boolean {
+  return (
+    error instanceof Error && "code" in error && (error as NodeJS.ErrnoException).code === "ENOENT"
+  );
+}
+
+function describeError(error: unknown): string {
+  if (error instanceof Error) {
+    return error.message;
+  }
+
+  return String(error);
+}