alchemylab-opencode 1.0.1 → 1.0.4

package/build.mjs

@@ -0,0 +1,153 @@
+import * as esbuild from 'esbuild'
+import { readFileSync, existsSync } from 'fs'
+import { join, resolve, extname } from 'path'
+
+const ROOT = resolve(import.meta.dirname)
+const SRC = join(ROOT, 'packages/opencode/src')
+const PACKAGES = join(ROOT, 'packages')
+
+const tsExtensions = ['.ts', '.tsx', '/index.ts', '/index.tsx']
+
+function resolveWithExtensions(path) {
+  if (extname(path) && existsSync(path)) return path
+  for (const ext of tsExtensions) {
+    const candidate = path + ext
+    if (existsSync(candidate)) return candidate
+  }
+  return null
+}
+
+// .txt → string export
+const txtPlugin = {
+  name: 'txt-loader',
+  setup(build) {
+    build.onLoad({ filter: /\.txt$/ }, async (args) => {
+      const text = readFileSync(args.path, 'utf8')
+      return { contents: `export default ${JSON.stringify(text)}`, loader: 'js' }
+    })
+  }
+}
+
+// #db / #pty → node implementations
+const conditionalImportsPlugin = {
+  name: 'conditional-imports',
+  setup(build) {
+    build.onResolve({ filter: /^#db$/ }, () => ({ path: join(SRC, 'storage/db.node.ts') }))
+    build.onResolve({ filter: /^#pty$/ }, () => ({ path: join(SRC, 'pty/pty.node.ts') }))
+  }
+}
+
+// @/ and @tui/ path aliases
+const aliasPlugin = {
+  name: 'path-aliases',
+  setup(build) {
+    build.onResolve({ filter: /^@\// }, (args) => {
+      const resolved = resolveWithExtensions(join(SRC, args.path.slice(2)))
+      return resolved ? { path: resolved } : undefined
+    })
+    build.onResolve({ filter: /^@tui\// }, (args) => {
+      const resolved = resolveWithExtensions(join(SRC, 'cli/cmd/tui', args.path.slice(5)))
+      return resolved ? { path: resolved } : undefined
+    })
+  }
+}
+
+// @opencode-ai/* → resolve to local packages source (bundle them)
+const opencodePackagesPlugin = {
+  name: 'opencode-packages',
+  setup(build) {
+    build.onResolve({ filter: /^@opencode-ai\// }, (args) => {
+      // @opencode-ai/plugin → packages/plugin/src/index.ts
+      // @opencode-ai/sdk → packages/sdk/src/index.ts  
+      // @opencode-ai/sdk/v2 → packages/sdk/src/v2/index.ts
+      // @opencode-ai/util/error → packages/util/src/error.ts
+      const parts = args.path.replace('@opencode-ai/', '').split('/')
+      const pkg = parts[0]  // plugin, sdk, util, script
+      const subpath = parts.slice(1).join('/')
+      
+      let target
+      if (subpath) {
+        target = join(PACKAGES, pkg, 'src', subpath)
+      } else {
+        target = join(PACKAGES, pkg, 'src', 'index')
+      }
+      
+      const resolved = resolveWithExtensions(target)
+      return resolved ? { path: resolved } : undefined
+    })
+  }
+}
+
+// Stub bun:* and bun imports
+const bunStubPlugin = {
+  name: 'bun-stub',
+  setup(build) {
+    build.onResolve({ filter: /^bun(:|$)/ }, (args) => ({
+      path: args.path, namespace: 'bun-stub',
+    }))
+    build.onLoad({ filter: /.*/, namespace: 'bun-stub' }, () => ({
+      contents: 'export default {}', loader: 'js',
+    }))
+  }
+}
+
+
+// Fix external imports that don't work in Node ESM without extensions
+const fixExternalImportsPlugin = {
+  name: 'fix-external-imports',
+  setup(build) {
+    const fixes = {
+      'vscode-jsonrpc/node': 'vscode-jsonrpc/node.js',
+      '@parcel/watcher/wrapper': '@parcel/watcher/wrapper.js',
+    }
+    for (const [from, to] of Object.entries(fixes)) {
+      build.onResolve({ filter: new RegExp('^' + from.replace(/[/\\]/g, '[\\/]') + '$') }, () => ({
+        path: to,
+        external: true,
+      }))
+    }
+  }
+}
+
+
+// Rewrite migration dir path for built output
+const migrationPathPlugin = {
+  name: 'migration-path',
+  setup(build) {
+    build.onLoad({ filter: /storage\/db\./ }, async (args) => {
+      const { readFileSync } = await import('fs')
+      let contents = readFileSync(args.path, 'utf8')
+      // Replace the hardcoded ../../migration with a path relative to the package root
+      // At runtime, import.meta.dirname in dist/ is the dist dir
+      // We want packages/opencode/migration relative to the package root
+      contents = contents.replace(
+        'path.join(import.meta.dirname, "../../migration")',
+        'path.join(import.meta.dirname, "../packages/opencode/migration")'
+      )
+      // Also handle the alternate form
+      contents = contents.replace(
+        "path.join(import.meta.dirname, '../../migration')",
+        "path.join(import.meta.dirname, '../packages/opencode/migration')"
+      )
+      return { contents, loader: 'ts' }
+    })
+  }
+}
+
+const result = await esbuild.build({
+  entryPoints: [join(SRC, 'serve.ts'), join(SRC, 'run.ts')],
+  bundle: true,
+  platform: 'node',
+  target: 'node22',
+  format: 'esm',
+  outdir: join(ROOT, 'dist'),
+  splitting: true,
+  sourcemap: true,
+  plugins: [txtPlugin, conditionalImportsPlugin, aliasPlugin, opencodePackagesPlugin, bunStubPlugin, fixExternalImportsPlugin, migrationPathPlugin],
+  packages: 'external',
+  
+  banner: { js: '// Built by esbuild from opencode-server source' },
+  logLevel: 'info',
+})
+
+if (result.errors.length > 0) process.exit(1)

package/dist/chunk-7JG6KCBC.js

@@ -0,0 +1,78 @@
+// Built by esbuild from opencode-server source
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
+    var dispose, inner;
+    if (async) dispose = value[__knownSymbol("asyncDispose")];
+    if (dispose === void 0) {
+      dispose = value[__knownSymbol("dispose")];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") __typeError("Object not disposable");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  };
+  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
+  var next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError) throw error;
+  };
+  return next();
+};
+
+export {
+  __require,
+  __export,
+  __reExport,
+  __using,
+  __callDispose
+};
+//# sourceMappingURL=chunk-7JG6KCBC.js.map

package/dist/chunk-7JG6KCBC.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}