@toolu/opencode 6.8.0

package/src/lifecycle/__tests__/lifecycle.test.ts

@@ -0,0 +1,7 @@
+import { expect, test } from "bun:test";
+import { lifecycleSupport } from "../table.ts";
+
+test("session/start and permission/evaluate supported after #204", () => {
+  expect(lifecycleSupport("session/start")).toBe("supported");
+  expect(lifecycleSupport("permission/evaluate")).toBe("supported");
+});

package/src/lifecycle/index.ts

@@ -0,0 +1,2 @@
+export { lifecycleSupport, lifecycleSupportTable } from "./table.ts";
+export type { LifecycleEvent, LifecycleSupport } from "./table.ts";

package/src/lifecycle/table.ts

@@ -0,0 +1,42 @@
+/**
+ * OpenCode lifecycle handler map.
+ * permission/evaluate hard-deny path is wired in #204; remaining session/tool
+ * hooks stay deferred until fuller host coverage / #212 evidence.
+ */
+
+export type LifecycleSupport = "supported" | "deferred" | "unsupported";
+
+export type LifecycleEvent =
+  | "session/start"
+  | "session/resume"
+  | "session/clear"
+  | "session/unload"
+  | "session/load"
+  | "prompt"
+  | "pre_compact"
+  | "permission/evaluate"
+  | "tool/pre"
+  | "tool/post"
+  | "shell/pre";
+
+const TABLE: Record<LifecycleEvent, LifecycleSupport> = {
+  "session/start": "supported",
+  "session/resume": "deferred",
+  "session/clear": "deferred",
+  "session/unload": "deferred",
+  "session/load": "deferred",
+  prompt: "unsupported",
+  pre_compact: "unsupported",
+  "permission/evaluate": "supported",
+  "tool/pre": "deferred",
+  "tool/post": "deferred",
+  "shell/pre": "deferred",
+};
+
+export function lifecycleSupport(event: LifecycleEvent): LifecycleSupport {
+  return TABLE[event];
+}
+
+export function lifecycleSupportTable(): Record<LifecycleEvent, LifecycleSupport> {
+  return { ...TABLE };
+}

package/src/plugin/__tests__/plugin-stub.test.ts

@@ -0,0 +1,6 @@
+import { expect, test } from "bun:test";
+import { classifyStub } from "../plugin-stub.ts";
+
+test("classifyStub uses core policy", () => {
+  expect(classifyStub("port-native")).toBe("port-native");
+});

package/src/plugin/plugin-stub.ts

@@ -0,0 +1,7 @@
+/** Thin compatibility surface — proves workspace import of @toolu/core. */
+import { parseClassification } from "@toolu/core/policy";
+
+/** Echo a classification through core to prove the workspace link. */
+export function classifyStub(token: string): string {
+  return parseClassification(token);
+}

package/src/plugin/toolu.ts

@@ -0,0 +1,142 @@
+/** OpenCode plugin entry — bootstrap + permission.evaluate bridge (#204). */
+import { Plugin } from "@opencode/plugin";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { bootstrapRuntime } from "../bootstrap/runtime.ts";
+import { runPreflight } from "../preflight/check.ts";
+import {
+  createDenyAllPermissionHandler,
+  createPermissionEvaluateHandler,
+} from "../adapter/evaluate.ts";
+import { selectPluginsWithDependencies } from "../select/resolve.ts";
+import { opencodeDataRoot } from "../host/roots.ts";
+
+function readNonEmptyString(value: unknown): string | undefined {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+/**
+ * The published package carries the bash plugins/ tree beside its sources, so an
+ * npm install needs no environment variable. Absent that copy — a contributor
+ * running from a clone — this returns undefined and the explicit sources win.
+ */
+function bundledRepoRoot(): string | undefined {
+  const packageRoot = join(import.meta.dir, "../..");
+  return existsSync(join(packageRoot, "plugins")) ? packageRoot : undefined;
+}
+
+function repoRootFromOptions(
+  options: Readonly<Record<string, unknown>>,
+  env: Record<string, string>,
+): string | undefined {
+  return (
+    readNonEmptyString(options.repoRoot) ??
+    readNonEmptyString(env.TOOLU_REPO_ROOT) ??
+    readNonEmptyString(env.TOOLU_ROOT) ??
+    bundledRepoRoot()
+  );
+}
+
+export type SetupTooluPermissionOptions = {
+  repoRoot: string;
+  projectRoot: string;
+  env?: Record<string, string>;
+};
+
+/** Wire permission.evaluate after preflight + bootstrap; deny-all when NotReady. */
+export async function setupTooluPermissionHook(
+  ctx: Pick<Plugin.Context, "permission" | "location">,
+  setupOpts: SetupTooluPermissionOptions,
+): Promise<void> {
+  const env = setupOpts.env ?? {};
+  const preflight = runPreflight({ env });
+  if (!preflight.bootstrapAllowed) {
+    const reason = preflight.reasons.join("; ") || "preflight failed";
+    await ctx.permission.hook(
+      "evaluate",
+      createDenyAllPermissionHandler(`toolu preflight: ${reason}`),
+    );
+    return;
+  }
+
+  const pluginsRoot = join(setupOpts.repoRoot, "plugins");
+  const selected = selectPluginsWithDependencies(pluginsRoot, setupOpts.projectRoot);
+  if (!selected.ok) {
+    await ctx.permission.hook(
+      "evaluate",
+      createDenyAllPermissionHandler(`toolu plugin selection: ${selected.reason}`),
+    );
+    return;
+  }
+
+  const dataRoot = opencodeDataRoot({
+    projectRoot: setupOpts.projectRoot,
+    env,
+  });
+
+  const bootstrap = await bootstrapRuntime({
+    repoRoot: setupOpts.repoRoot,
+    projectRoot: setupOpts.projectRoot,
+    dataRoot,
+    plugins: selected.plugins,
+    env,
+  });
+
+  if (bootstrap.status !== "ready") {
+    await ctx.permission.hook(
+      "evaluate",
+      createDenyAllPermissionHandler(`toolu bootstrap: ${bootstrap.reason}`),
+    );
+    return;
+  }
+
+  const bridgeContext = {
+    cwd: ctx.location.directory,
+    projectRoot: setupOpts.projectRoot,
+    worktree: ctx.location.directory,
+    host: "opencode",
+  };
+
+  const handler = createPermissionEvaluateHandler({
+    repoRoot: setupOpts.repoRoot,
+    bridgeContext,
+    env: {
+      ...env,
+      TOOLU_SETTINGS_DIR: join(setupOpts.repoRoot, "plugins/toolu/settings"),
+      TOOLU_HOST_OVERRIDE: "opencode",
+    },
+  });
+
+  await ctx.permission.hook("evaluate", handler);
+}
+
+export default Plugin.define({
+  id: "toolu",
+  async setup(ctx) {
+    const env: Record<string, string> = {};
+    for (const [key, value] of Object.entries(process.env)) {
+      if (value !== undefined) {
+        env[key] = value;
+      }
+    }
+
+    const optionsRecord: Record<string, unknown> = { ...ctx.options };
+    const repoRoot = repoRootFromOptions(optionsRecord, env);
+    if (!repoRoot) {
+      await ctx.permission.hook(
+        "evaluate",
+        createDenyAllPermissionHandler(
+          "toolu: no bundled plugins/ tree; set plugin option repoRoot or TOOLU_REPO_ROOT",
+        ),
+      );
+      return;
+    }
+
+    const projectRoot = ctx.location.project.directory;
+    await setupTooluPermissionHook(ctx, {
+      repoRoot,
+      projectRoot,
+      env,
+    });
+  },
+});

package/src/preflight/__tests__/preflight.test.ts

@@ -0,0 +1,20 @@
+import { expect, test } from "bun:test";
+import { mkdtempSync } from "node:fs";
+import { join } from "node:path";
+import { runPreflight } from "../check.ts";
+
+const tmpBase = process.env.TMPDIR ?? "/tmp";
+
+test("preflight reports bash and jq when PATH is normal", () => {
+  const report = runPreflight();
+  expect(report.entries.find((e) => e.tool === "bash")?.present).toBe(true);
+  expect(report.entries.find((e) => e.tool === "jq")?.present).toBe(true);
+  expect(report.bootstrapAllowed).toBe(true);
+});
+
+test("preflight fail closed when jq is not on PATH", () => {
+  const emptyPath = mkdtempSync(join(tmpBase, "toolu-pf-path-"));
+  const report = runPreflight({ env: { PATH: emptyPath } });
+  expect(report.bootstrapAllowed).toBe(false);
+  expect(report.reasons.some((r) => r.includes("jq"))).toBe(true);
+});

package/src/preflight/check.ts

@@ -0,0 +1,75 @@
+/** Prerequisite probe for OpenCode bootstrap (#211). */
+import { statSync } from "node:fs";
+import { join } from "node:path";
+
+export type PreflightTool = "bash" | "jq" | "git" | "bun" | "opencode";
+
+export type PreflightEntry = {
+  tool: PreflightTool;
+  present: boolean;
+  detail?: string;
+};
+
+export type PreflightReport = {
+  entries: PreflightEntry[];
+  bootstrapAllowed: boolean;
+  reasons: string[];
+};
+
+const REQUIRED_FOR_BOOTSTRAP: PreflightTool[] = ["bash", "jq"];
+
+const ALLOWED_BINARY = /^[A-Za-z0-9._+-]+$/;
+
+/** PATH lookup without shell — binary must be a simple tool name. */
+function commandPresent(binary: string, env: Record<string, string>): boolean {
+  if (!ALLOWED_BINARY.test(binary)) {
+    return false;
+  }
+  const pathEnv = env.PATH ?? process.env.PATH ?? "";
+  for (const dir of pathEnv.split(":")) {
+    if (dir.length === 0) {
+      continue;
+    }
+    const candidate = join(dir, binary);
+    try {
+      if (statSync(candidate).isFile()) {
+        return true;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return false;
+}
+
+/** Structured prerequisite report; missing bash/jq fail closed for bootstrap. */
+function stringEnv(source: NodeJS.ProcessEnv): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const [key, value] of Object.entries(source)) {
+    if (value !== undefined) {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+
+export function runPreflight(options?: { env?: Record<string, string> }): PreflightReport {
+  const env = { ...stringEnv(process.env), ...options?.env };
+  const tools: PreflightTool[] = ["bash", "jq", "git", "bun", "opencode"];
+  const entries: PreflightEntry[] = tools.map((tool) => ({
+    tool,
+    present: commandPresent(tool, env),
+  }));
+  const reasons: string[] = [];
+  for (const required of REQUIRED_FOR_BOOTSTRAP) {
+    const entry = entries.find((e) => e.tool === required);
+    if (entry && !entry.present) {
+      reasons.push(`missing required tool: ${required}`);
+    }
+  }
+  return {
+    entries,
+    bootstrapAllowed: reasons.length === 0,
+    reasons,
+  };
+}

package/src/preflight/index.ts

@@ -0,0 +1,2 @@
+export { runPreflight } from "./check.ts";
+export type { PreflightEntry, PreflightReport, PreflightTool } from "./check.ts";

package/src/select/__tests__/select.test.ts

@@ -0,0 +1,52 @@
+import { expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { selectPluginsWithDependencies } from "../resolve.ts";
+import { opencodePluginSelectionPath } from "../../host/roots.ts";
+
+const tmpBase = process.env.TMPDIR ?? "/tmp";
+
+function writeManifest(
+  pluginsRoot: string,
+  name: string,
+  dependencies: Array<{ name: string; marketplace: string }> = [],
+): void {
+  const dir = join(pluginsRoot, name, ".claude-plugin");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, "plugin.json"), JSON.stringify({ name, version: "1.0.0", dependencies }));
+}
+
+test("select fails closed on missing dependency", () => {
+  const project = mkdtempSync(join(tmpBase, "toolu-sel-proj-"));
+  const pluginsRoot = mkdtempSync(join(tmpBase, "toolu-sel-pl-"));
+  writeManifest(pluginsRoot, "ts-quality", [{ name: "toolu", marketplace: "toolu" }]);
+  mkdirSync(join(project, ".opencode", "toolu"), { recursive: true });
+  writeFileSync(
+    opencodePluginSelectionPath(project),
+    JSON.stringify({ version: 1, enabled: ["ts-quality"] }),
+  );
+  const result = selectPluginsWithDependencies(pluginsRoot, project);
+  expect(result.ok).toBe(false);
+  if (result.ok) {
+    return;
+  }
+  expect(result.missingDependency).toBe("toolu");
+});
+
+test("select includes dependency closure", () => {
+  const project = mkdtempSync(join(tmpBase, "toolu-sel-cl-"));
+  const pluginsRoot = mkdtempSync(join(tmpBase, "toolu-sel-cl-pl-"));
+  writeManifest(pluginsRoot, "toolu");
+  writeManifest(pluginsRoot, "ts-quality", [{ name: "toolu", marketplace: "toolu" }]);
+  mkdirSync(join(project, ".opencode", "toolu"), { recursive: true });
+  writeFileSync(
+    opencodePluginSelectionPath(project),
+    JSON.stringify({ version: 1, enabled: ["ts-quality"] }),
+  );
+  const result = selectPluginsWithDependencies(pluginsRoot, project);
+  expect(result.ok).toBe(true);
+  if (!result.ok) {
+    return;
+  }
+  expect(result.plugins.map((p) => p.name).toSorted()).toEqual(["toolu", "ts-quality"]);
+});

package/src/select/index.ts

@@ -0,0 +1,2 @@
+export { selectPluginsByEnabledNames, selectPluginsWithDependencies } from "./resolve.ts";
+export type { SelectResult } from "./resolve.ts";

package/src/select/resolve.ts

@@ -0,0 +1,87 @@
+/** Enabled plugin set + dependency closure (#211). */
+import { pluginSpec } from "../inventory/manifest.ts";
+import { listPluginManifests } from "../inventory/scan.ts";
+import { resolveEnabledPluginNames } from "../inventory/selection.ts";
+import type { PluginManifest } from "../inventory/types.ts";
+
+export type SelectResult =
+  | { ok: true; plugins: PluginManifest[] }
+  | { ok: false; reason: string; missingDependency?: string };
+
+function manifestByName(manifests: PluginManifest[]): Map<string, PluginManifest> {
+  const map = new Map<string, PluginManifest>();
+  for (const m of manifests) {
+    map.set(m.name, m);
+  }
+  return map;
+}
+
+function closePluginDependencies(
+  pluginsRoot: string,
+  byName: Map<string, PluginManifest>,
+  seedNames: Iterable<string>,
+): SelectResult {
+  const queue = [...seedNames];
+  const selected = new Set<string>();
+  const ordered: PluginManifest[] = [];
+
+  while (queue.length > 0) {
+    const name = queue.shift();
+    if (!name || selected.has(name)) {
+      continue;
+    }
+    const manifest = byName.get(name);
+    if (!manifest) {
+      return {
+        ok: false,
+        reason: `enabled plugin "${name}" is not installed under ${pluginsRoot}`,
+        missingDependency: name,
+      };
+    }
+    selected.add(name);
+    ordered.push(manifest);
+    for (const dep of manifest.dependencies) {
+      if (!byName.has(dep.name)) {
+        return {
+          ok: false,
+          reason: `plugin "${manifest.spec}" requires missing dependency ${pluginSpec(dep.name, dep.marketplace)}`,
+          missingDependency: dep.name,
+        };
+      }
+      if (!selected.has(dep.name)) {
+        queue.push(dep.name);
+      }
+    }
+  }
+
+  return { ok: true, plugins: ordered };
+}
+
+/** Resolve enabled plugins and transitive manifest dependencies. */
+export function selectPluginsWithDependencies(
+  pluginsRoot: string,
+  projectRoot: string,
+): SelectResult {
+  const enabledResult = resolveEnabledPluginNames(pluginsRoot, projectRoot);
+  if (!enabledResult.ok) {
+    return { ok: false, reason: enabledResult.reason };
+  }
+
+  const allManifests = listPluginManifests(pluginsRoot);
+  if (allManifests === null) {
+    return { ok: false, reason: `cannot read plugins root: ${pluginsRoot}` };
+  }
+  return closePluginDependencies(pluginsRoot, manifestByName(allManifests), enabledResult.enabled);
+}
+
+/** Resolve an explicit enabled list plus manifest dependency closure (#211). */
+export function selectPluginsByEnabledNames(
+  pluginsRoot: string,
+  enabledNames: readonly string[],
+): SelectResult {
+  const allManifests = listPluginManifests(pluginsRoot);
+  if (allManifests === null) {
+    return { ok: false, reason: `cannot read plugins root: ${pluginsRoot}` };
+  }
+  return closePluginDependencies(pluginsRoot, manifestByName(allManifests), enabledNames);
+}