@diologue/local-agent 0.1.5 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diologue/local-agent",
-  "version": "0.1.5",
+  "version": "0.2.0",
   "type": "module",
   "description": "Diologue Coding Agent — local helper that pairs the cloud web UI with opencode running against a git repo on your machine. Binds to 127.0.0.1 only.",
   "license": "MIT",
@@ -14,8 +14,6 @@
   },
   "files": [
     "dist",
-    "scripts/postinstall.ts",
-    "src/lib/engine-bundle.ts",
     "engine-release.json",
     "README.md"
   ],
@@ -30,11 +28,11 @@
     "check": "tsc --noEmit",
     "test": "tsx --test src/*.test.ts src/**/*.test.ts",
     "verify-sdk": "tsx src/scripts/verify-sdk.ts",
-    "pair": "tsx src/cli.ts pair",
-    "postinstall": "node dist/postinstall.mjs || true"
+    "pair": "tsx src/cli.ts pair"
   },
   "dependencies": {
     "@opencode-ai/sdk": "^1.15.13",
+    "opencode-ai": "1.16.2",
     "express": "^4.21.2",
     "open": "^10.1.0",
     "zod": "^3.24.2"

package/scripts/postinstall.ts

@@ -1,191 +0,0 @@
-// local-agent postinstall — runs after `npm install @diologue/local-agent`.
-//
-// Responsibility: download the diologue-engine bundle for this host's
-// platform/arch from GitHub Releases and write it under
-// local-agent/dist/engine/<releaseTag>/.
-//
-// Behavior:
-//   - Best-effort. Failures here should NEVER block the install — the
-//     helper can still run via LOCAL_AGENT_ENGINE=npm, and the runtime
-//     surfaces a clear error if no engine is reachable. We print a
-//     loud warning instead of throwing.
-//   - Honours SKIP_DIOLOGUE_POSTINSTALL=1 for CI and offline setups.
-//   - Idempotent: if the target file already exists, exits early.
-//   - Unsupported platforms (e.g. freebsd) print a one-line warning
-//     and exit 0.
-//
-// Source of truth for what to fetch: local-agent/engine-release.json.
-
-import { chmod, mkdir, rename, stat, writeFile } from "node:fs/promises";
-import { createWriteStream } from "node:fs";
-import { pipeline } from "node:stream/promises";
-import { Readable } from "node:stream";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-import {
-  BUNDLE_DIR_INSTALLED,
-  bundleFilename,
-  downloadUrlForHost,
-  engineRelease,
-  supportedTargetForHost,
-} from "../src/lib/engine-bundle";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-const SKIP_ENV = "SKIP_DIOLOGUE_POSTINSTALL" as const;
-
-const log = (msg: string): void => {
-  // Prefix consistently so users can grep their npm-install log.
-  process.stdout.write(`[diologue/postinstall] ${msg}\n`);
-};
-const warn = (msg: string): void => {
-  process.stderr.write(`[diologue/postinstall] ${msg}\n`);
-};
-
-export interface PostinstallOptions {
-  /** Where to put the downloaded bundle. Defaults to BUNDLE_DIR_INSTALLED. */
-  destinationDir?: string;
-  /** Override for the fetch function. Tests inject a mock. */
-  fetchImpl?: typeof fetch;
-  /** Force a re-download even if the file already exists. */
-  force?: boolean;
-  /** Skip the actual write (dry-run). */
-  dryRun?: boolean;
-}
-
-export interface PostinstallResult {
-  status: "installed" | "already-present" | "skipped" | "unsupported" | "failed";
-  /** Reason for skipped/unsupported/failed. */
-  reason?: string;
-  /** Path to the installed bundle (when status is installed or already-present). */
-  bundlePath?: string;
-}
-
-export const runPostinstall = async (
-  options: PostinstallOptions = {},
-): Promise<PostinstallResult> => {
-  if (process.env[SKIP_ENV] === "1") {
-    return { status: "skipped", reason: `${SKIP_ENV}=1 set` };
-  }
-
-  const target = supportedTargetForHost();
-  if (!target) {
-    return {
-      status: "unsupported",
-      reason: `No bundle for ${process.platform}/${process.arch}. ` +
-        `Supported: ${engineRelease.targets
-          .map((t) => `${t.platform}/${t.arch}`)
-          .join(", ")}. ` +
-        `Helper will still work via LOCAL_AGENT_ENGINE=npm.`,
-    };
-  }
-
-  const url = downloadUrlForHost()!;
-  const destinationDir = options.destinationDir ?? BUNDLE_DIR_INSTALLED;
-  const destination = path.join(destinationDir, bundleFilename());
-
-  if (!options.force) {
-    try {
-      const s = await stat(destination);
-      if (s.isFile() && s.size > 0) {
-        return {
-          status: "already-present",
-          bundlePath: destination,
-        };
-      }
-    } catch {
-      // not present — fall through to download
-    }
-  }
-
-  if (options.dryRun) {
-    return {
-      status: "installed",
-      bundlePath: destination,
-      reason: `dry-run: would fetch ${url}`,
-    };
-  }
-
-  const fetchImpl = options.fetchImpl ?? fetch;
-  let response: Response;
-  try {
-    response = await fetchImpl(url);
-  } catch (err) {
-    return {
-      status: "failed",
-      reason: `Network error fetching ${url}: ${(err as Error).message}`,
-    };
-  }
-  if (!response.ok || !response.body) {
-    return {
-      status: "failed",
-      reason: `HTTP ${response.status} fetching ${url}. ` +
-        `If the engine release isn't published yet, set ` +
-        `LOCAL_AGENT_ENGINE=npm to use the legacy MVP path.`,
-    };
-  }
-
-  await mkdir(destinationDir, { recursive: true });
-  const tmp = destination + ".part";
-  try {
-    await pipeline(
-      // Node's fetch returns a Web ReadableStream; convert to Node stream.
-      Readable.fromWeb(response.body as never),
-      createWriteStream(tmp),
-    );
-    await chmod(tmp, 0o755);
-    await rename(tmp, destination);
-  } catch (err) {
-    return {
-      status: "failed",
-      reason: `Write error: ${(err as Error).message}`,
-    };
-  }
-
-  return { status: "installed", bundlePath: destination };
-};
-
-// ---- CLI ------------------------------------------------------------
-
-const isMain =
-  process.argv[1] !== undefined &&
-  fileURLToPath(import.meta.url) === path.resolve(process.argv[1]);
-
-if (isMain) {
-  runPostinstall()
-    .then((result) => {
-      switch (result.status) {
-        case "installed":
-          log(`installed → ${result.bundlePath}`);
-          break;
-        case "already-present":
-          log(`already present → ${result.bundlePath}`);
-          break;
-        case "skipped":
-          log(`skipped: ${result.reason ?? "no reason given"}`);
-          break;
-        case "unsupported":
-          warn(result.reason ?? "unsupported");
-          break;
-        case "failed":
-          warn(`bundle install failed — ${result.reason ?? "unknown"}`);
-          warn(
-            "The helper will still install. " +
-              "Set LOCAL_AGENT_ENGINE=npm to use the legacy MVP path, " +
-              "or re-run the install once the engine release is published.",
-          );
-          break;
-      }
-    })
-    .catch((err: Error) => {
-      // Unexpected — log and exit 0 anyway so we don't break npm install.
-      warn(`unexpected failure: ${err.message}`);
-      warn("Continuing without bundle. Set LOCAL_AGENT_ENGINE=npm to use the legacy path.");
-    });
-}
-
-// Suppress unused-var warning when this file is consumed only as a CLI.
-void __dirname;
-void writeFile;

package/src/lib/engine-bundle.ts

@@ -1,123 +0,0 @@
-// Engine-bundle discovery — finds the standalone diologue-engine binary
-// that postinstall (or `npm run build-engine-bundle`) produced on this
-// machine.
-//
-// Discovery order (first hit wins):
-//   1. LOCAL_AGENT_ENGINE_BUNDLE env var — explicit override (tests + dev)
-//   2. <local-agent>/dist/engine/<releaseTag>/diologue-engine-<plat>-<arch><ext>
-//      — where postinstall.ts writes the downloaded bundle
-//   3. <repo>/build/diologue-engine-bundles/diologue-engine-<plat>-<arch><ext>
-//      — where build-engine-bundle.ts writes a locally-built bundle
-//
-// Returning null means "no bundle on this machine"; the caller decides
-// whether to fall back to a different engine path or surface an error.
-
-import { access, constants } from "node:fs/promises";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-import engineReleaseRaw from "../../engine-release.json" with { type: "json" };
-
-interface EngineRelease {
-  version: string;
-  releaseTag: string;
-  downloadBase: string;
-  targets: Array<{
-    platform: NodeJS.Platform;
-    arch: NodeJS.Architecture;
-    bunTarget: string;
-    ext: string;
-  }>;
-}
-
-export const engineRelease = engineReleaseRaw as EngineRelease;
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// local-agent/src/lib → local-agent root is two levels up.
-const LOCAL_AGENT_ROOT = path.resolve(__dirname, "../..");
-// local-agent → repo root is one level up.
-const REPO_ROOT = path.resolve(LOCAL_AGENT_ROOT, "..");
-
-export const BUNDLE_DIR_INSTALLED = path.join(
-  LOCAL_AGENT_ROOT,
-  "dist/engine",
-  engineRelease.releaseTag,
-);
-
-export const BUNDLE_DIR_LOCAL_BUILD = path.join(
-  REPO_ROOT,
-  "build/diologue-engine-bundles",
-);
-
-export const ENGINE_BUNDLE_ENV = "LOCAL_AGENT_ENGINE_BUNDLE" as const;
-
-export interface ResolvedBundle {
-  /** Absolute path to the executable. */
-  path: string;
-  /** Where it came from — useful for logging + tests. */
-  source: "env" | "installed" | "local-build";
-}
-
-const exists = async (p: string): Promise<boolean> => {
-  try {
-    await access(p, constants.X_OK);
-    return true;
-  } catch {
-    return false;
-  }
-};
-
-/** Build the canonical bundle filename for a given target. The
- *  postinstall script uses this name to write the artifact; the build
- *  script writes the same name. */
-export const bundleFilename = (
-  platform: NodeJS.Platform = process.platform,
-  arch: NodeJS.Architecture = process.arch,
-): string => {
-  const target = engineRelease.targets.find(
-    (t) => t.platform === platform && t.arch === arch,
-  );
-  const ext = target?.ext ?? "";
-  return `diologue-engine-${platform}-${arch}${ext}`;
-};
-
-/** Return the bundle target for this host, or undefined if unsupported. */
-export const supportedTargetForHost = ():
-  | EngineRelease["targets"][number]
-  | undefined => {
-  return engineRelease.targets.find(
-    (t) => t.platform === process.platform && t.arch === process.arch,
-  );
-};
-
-/** Search for an engine bundle on the local machine. Returns null
- *  when nothing is found. */
-export const findEngineBundle = async (): Promise<ResolvedBundle | null> => {
-  const fromEnv = process.env[ENGINE_BUNDLE_ENV];
-  if (fromEnv) {
-    if (await exists(fromEnv)) {
-      return { path: fromEnv, source: "env" };
-    }
-    // env var set but file missing — fall through so the caller still
-    // gets a useful "not found" rather than a half-broken path.
-  }
-  const filename = bundleFilename();
-  const installed = path.join(BUNDLE_DIR_INSTALLED, filename);
-  if (await exists(installed)) {
-    return { path: installed, source: "installed" };
-  }
-  const localBuild = path.join(BUNDLE_DIR_LOCAL_BUILD, filename);
-  if (await exists(localBuild)) {
-    return { path: localBuild, source: "local-build" };
-  }
-  return null;
-};
-
-/** Compose the download URL for the engine bundle on this host. */
-export const downloadUrlForHost = (): string | null => {
-  const target = supportedTargetForHost();
-  if (!target) return null;
-  return `${engineRelease.downloadBase}/${engineRelease.releaseTag}/${bundleFilename()}`;
-};