@opencode/server 2.0.4 → 2.0.6

package/dist/api.d.ts

@@ -2,6 +2,38 @@ import { LocationMiddleware } from "./location";
 import { FormLocationMiddleware } from "./middleware/form-location";
 import { SessionLocationMiddleware } from "./middleware/session-location";
 export declare const Api: import("@opencode/protocol/api").Api<LocationMiddleware, import("effect/unstable/httpapi/HttpApiMiddleware").HttpApiMiddleware<import("@opencode/core/instance").Services, never, never>, FormLocationMiddleware, import("effect/unstable/httpapi/HttpApiMiddleware").HttpApiMiddleware<import("@opencode/core/instance").Services, readonly [typeof import("@opencode/protocol/errors").InvalidRequestError, typeof import("@opencode/protocol/errors").SessionNotFoundError], never>, SessionLocationMiddleware, import("effect/unstable/httpapi/HttpApiMiddleware").HttpApiMiddleware<import("@opencode/core/instance").Services, readonly [typeof import("@opencode/protocol/errors").InvalidRequestError, typeof import("@opencode/protocol/errors").SessionNotFoundError], never>, import("effect/unstable/httpapi/HttpApiGroup").HttpApiGroup<"server.event", import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"event.subscribe", "GET", "/api/event", never, never, never, never, import("effect/unstable/httpapi/HttpApiSchema").StreamSse<import("effect/unstable/httpapi/HttpApiSchema").SseEventFromData<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+    readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: import("effect/Schema").Finite;
+    readonly metadata: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>, never, never>;
+    readonly type: import("effect/Schema").Literal<"location.shutdown">;
+    readonly location: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+        readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+        readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+        readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+        readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: import("effect/Schema").Struct<{}>;
+}> & {
+    type: "location.shutdown";
+    durability: "ephemeral";
+    durable: undefined;
+    data: import("effect/Schema").Struct<{}>;
+}, import("effect/Schema").Struct<{
     readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.ID">;
     };
@@ -8086,6 +8118,18 @@ export declare const Api: import("@opencode/protocol/api").Api<LocationMiddlewar
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
+} | {
+    readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+    readonly data: {};
+    readonly type: "location.shutdown";
+    readonly created: number;
+    readonly location?: {
+        readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
+        readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
+    } | undefined;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
 } | {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly data: {

package/dist/handlers/fs.js

@@ -16,5 +16,7 @@ export const FileSystemHandler = HttpApiBuilder.group(Api, "server.fs", (handler
     return yield* (yield* FileSystem.Service).list(ctx.query);
   }))).handle("fs.find", (ctx) => response(Effect.gen(function* () {
     return yield* (yield* FileSystem.Service).find(ctx.query);
+  }))).handle("fs.write", (ctx) => response(Effect.gen(function* () {
+    return yield* (yield* FileSystem.Service).write({ path: ctx.query.path, data: ctx.payload });
   })));
 }));

package/dist/handlers/location.d.ts

@@ -1 +1,2 @@
-export declare const LocationHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.location">, never, import("@opencode/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization | import("../location").LocationMiddleware>;
+import { LocationServiceMap } from "@opencode/core/location-service-map";
+export declare const LocationHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.location">, never, import("@opencode/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization | LocationServiceMap.Service | import("../location").LocationMiddleware>;

package/dist/handlers/location.js

@@ -1,11 +1,16 @@
 import { Location } from "@opencode/core/location";
-import { Effect } from "effect";
+import { LocationServiceMap } from "@opencode/core/location-service-map";
+import { ServiceUnavailableError } from "@opencode/protocol/errors";
+import { Cause, Effect } from "effect";
 import { HttpApiBuilder } from "effect/unstable/httpapi";
 import { Api } from "../api";
-export const LocationHandler = HttpApiBuilder.group(Api, "server.location", (handlers) => handlers.handle("location.get", Effect.fn(function* () {
-  const location = yield* Location.Service;
-  return new Location.Info({
-    directory: location.directory,
-    project: location.project
-  });
-})));
+export const LocationHandler = HttpApiBuilder.group(Api, "server.location", (handlers) => Effect.gen(function* () {
+  const locations = yield* LocationServiceMap.Service;
+  return handlers.handle("location.get", Effect.fn(function* () {
+    const location = yield* Location.Service;
+    return new Location.Info({
+      directory: location.directory,
+      project: location.project
+    });
+  })).handle("location.reload", () => LocationServiceMap.reload().pipe(Effect.provideService(LocationServiceMap.Service, locations), Effect.catchCause((cause) => Cause.hasInterruptsOnly(cause) ? Effect.failCause(cause) : Effect.fail(new ServiceUnavailableError({ message: Cause.pretty(cause), service: "location" })))));
+}));

package/dist/handlers/server.js

@@ -2,11 +2,12 @@ import { Effect } from "effect";
 import { HttpApiBuilder } from "effect/unstable/httpapi";
 import { Api } from "../api";
 import { ServerInfo } from "../server-info";
-export const ServerHandler = HttpApiBuilder.group(Api, "server.server", (handlers) => handlers.handle("server.status", () => Effect.gen(function* () {
+export const ServerHandler = HttpApiBuilder.group(Api, "server.server", (handlers) => handlers.handle("server.info", () => Effect.gen(function* () {
   const info = yield* ServerInfo.Service;
   return {
     version: info.app.version ?? "unknown",
     pid: process.pid ?? 0,
-    urls: info.urls()
+    urls: info.urls(),
+    paths: info.paths
   };
 })));

package/dist/process.js

@@ -5,6 +5,7 @@ import { SessionRestart } from "@opencode/core/session/execution/restart";
 import { InstallationEvent } from "@opencode/schema/installation-event";
 import { hasPtyConnectTicketURL } from "@opencode/protocol/groups/pty";
 import { hasPersistentPtyConnectTicketURL } from "@opencode/protocol/groups/persistent-pty";
+import { Global } from "@opencode/util/global";
 import { Cause, Context, Effect, Exit, Latch, Layer, Option, Ref, Scope } from "effect";
 import {
   HttpMiddleware,
@@ -34,7 +35,7 @@ export const start = Effect.fn("ServerProcess.start")(function* (options, lifecy
     const host = address.family === "IPv6" ? `[${address.address}]` : address.address;
     return ServerInfo.connectionURLs(`http://${host}:${address.port}`, hostname);
   }, application = yield* Ref.make(Option.none());
-  yield* bound.http.serve(dispatch(password, status, application, options.app?.version ?? "unknown", urls).pipe(HttpMiddleware.cors({ allowedOrigins: (origin) => isAllowedCorsOrigin(origin, options), maxAge: 86400 })), errorResponseLogger).pipe(withoutParentSpan);
+  yield* bound.http.serve(dispatch(password, status, application, options.app?.version ?? "unknown", urls, Global.Path.tmp).pipe(HttpMiddleware.cors({ allowedOrigins: (origin) => isAllowedCorsOrigin(origin, options), maxAge: 86400 })), errorResponseLogger).pipe(withoutParentSpan);
   if (lifecycle)
     yield* lifecycle.onListen(bound.http.address, shutdown.open.pipe(Effect.asVoid)).pipe(Effect.flatMap((cleanup) => Effect.addFinalizer(() => Scope.close(bound.scope, Exit.void).pipe(Effect.andThen(cleanup)))), Effect.uninterruptible);
   const parentScope = yield* Scope.Scope, applicationScope = yield* Scope.fork(parentScope);
@@ -87,16 +88,15 @@ function addressInUse(error) {
   const cause = error.cause;
   return typeof cause === "object" && cause !== null && "code" in cause && cause.code === "EADDRINUSE";
 }
-function dispatch(password, status, application, version, urls) {
+function dispatch(password, status, application, version, urls, tmp) {
   const auth = ServerAuth.Config.of({ password: Option.some(password), username: "opencode" });
   return Effect.gen(function* () {
-    const request = yield* HttpServerRequest.HttpServerRequest, url = new URL(request.url, "http://localhost");
-    if (request.method === "GET" && url.pathname === "/api/status") {
+    const request = yield* HttpServerRequest.HttpServerRequest, url = new URL(request.url, "http://localhost"), state = yield* status.current, app = yield* Ref.get(application), ready = state.type === "ready" && Option.isSome(app);
+    if (request.method === "GET" && url.pathname === "/api/info" && !ready) {
       if (!(yield* authorizedRequest(request, auth)))
         return unauthorized();
-      return yield* statusResponse(status, version, urls);
+      return yield* infoResponse(status, version, urls, tmp);
     }
-    const state = yield* status.current, app = yield* Ref.get(application), ready = state.type === "ready" && Option.isSome(app);
     if ((!ready || !hasPtyConnectTicketURL(url) && !hasPersistentPtyConnectTicketURL(url)) && !(yield* authorizedRequest(request, auth)))
       return unauthorized();
     if (ready)
@@ -110,9 +110,9 @@ function unauthorized() {
     headers: { "www-authenticate": 'Basic realm="Secure Area"' }
   });
 }
-const statusResponse = Effect.fnUntraced(function* (status, version, urls) {
+const infoResponse = Effect.fnUntraced(function* (status, version, urls, tmp) {
   const state = yield* status.current;
-  return HttpServerResponse.jsonUnsafe({ version, pid: process.pid, urls: urls() }, {
+  return HttpServerResponse.jsonUnsafe({ version, pid: process.pid, urls: urls(), paths: { tmp } }, {
     status: state.type === "ready" ? 200 : state.type === "failed" ? 500 : 503,
     headers: state.type === "starting" || state.type === "stopping" ? { "retry-after": "1" } : void 0
   });

package/dist/routes.js

@@ -112,7 +112,7 @@ function makeRoutes(auth, options, serviceURLs, overrides, instances) {
     const { simulationReplacements } = yield* Effect.promise(() => import("@opencode/simulation/backend")), simulation = yield* simulationReplacements({ version: App.make(options.app).version });
     return build([...overrides, ...simulation]);
   })) : build(overrides)).pipe(Layer.flatMap((context) => {
-    const services = Layer.succeedContext(context), requestServices = Layer.merge(Layer.succeedContext(Context.pick(Database.Service, Credential.Service, PermissionSaved.Service, PluginUpdate.Service, Project.Service, WellKnown.Service)(context)), ServerInfo.layer(serviceURLs, options.app)), api = HttpApiBuilder.layer(Api, { openapiPath: "/openapi.json" }).pipe(Layer.provide(handlers.pipe(Layer.provide(services), Layer.provide(Layer.succeed(CorsConfig, options)))), Layer.provide(formLocationLayer), Layer.provide(sessionLocationLayer), Layer.provide(layer), Layer.provide(authorizationLayer), Layer.provide(schemaErrorLayer), Layer.provide(auth), HttpRouter.provideRequest(requestServices), Layer.provideMerge(services), Layer.provideMerge(HttpRouter.layer));
+    const services = Layer.succeedContext(context), requestServices = Layer.merge(Layer.succeedContext(Context.pick(Database.Service, Credential.Service, PermissionSaved.Service, PluginUpdate.Service, Project.Service, WellKnown.Service)(context)), ServerInfo.layer(serviceURLs, Context.get(context, Global.Service).tmp, options.app)), api = HttpApiBuilder.layer(Api, { openapiPath: "/openapi.json" }).pipe(Layer.provide(handlers.pipe(Layer.provide(services), Layer.provide(Layer.succeed(CorsConfig, options)))), Layer.provide(formLocationLayer), Layer.provide(sessionLocationLayer), Layer.provide(layer), Layer.provide(authorizationLayer), Layer.provide(schemaErrorLayer), Layer.provide(auth), HttpRouter.provideRequest(requestServices), Layer.provideMerge(services), Layer.provideMerge(HttpRouter.layer));
     return Layer.merge(api, V1Migration.layer.pipe(Layer.provide(services)));
   }));
 }

package/dist/server-info.d.ts

@@ -3,9 +3,12 @@ import type { ServerOptions } from "./options";
 declare const Service_base: Context.ServiceClass<Service, "@opencode/server/ServerInfo", {
     readonly urls: () => ReadonlyArray<string>;
     readonly app: NonNullable<ServerOptions["app"]>;
+    readonly paths: {
+        readonly tmp: string;
+    };
 }>;
 export declare class Service extends Service_base {
 }
-export declare function layer(urls: () => ReadonlyArray<string>, app?: ServerOptions["app"]): Layer.Layer<Service, never, never>;
+export declare function layer(urls: () => ReadonlyArray<string>, tmp: string, app?: ServerOptions["app"]): Layer.Layer<Service, never, never>;
 export declare function connectionURLs(value: string, requestedHostname?: string): string[];
 export * as ServerInfo from "./server-info";

package/dist/server-info.js

@@ -3,8 +3,8 @@ import { networkInterfaces } from "node:os";
 
 export class Service extends Context.Service()("@opencode/server/ServerInfo") {
 }
-export function layer(urls, app = {}) {
-  return Layer.succeed(Service, Service.of({ urls, app }));
+export function layer(urls, tmp, app = {}) {
+  return Layer.succeed(Service, Service.of({ urls, app, paths: { tmp } }));
 }
 export function connectionURLs(value, requestedHostname) {
   const url = new URL(value), hostname = requestedHostname ?? url.hostname, family = hostname === "0.0.0.0" ? "IPv4" : hostname === "::" || hostname === "[::]" ? "IPv6" : void 0;

package/dist/workerd.js

@@ -47,7 +47,8 @@ const unavailable = (what) => Effect.die(Error(`${what} is unavailable in the wo
 })), fileSystemLayer = Layer.succeed(FileSystem.Service, FileSystem.Service.of({
   read: () => unavailable("FileSystem.read"),
   list: () => unavailable("FileSystem.list"),
-  find: () => unavailable("FileSystem.find")
+  find: () => unavailable("FileSystem.find"),
+  write: () => unavailable("FileSystem.write")
 })), fileSystemSearchLayer = Layer.succeed(FileSystemSearch.Service, FileSystemSearch.Service.of({
   find: () => unavailable("FileSystemSearch.find")
 })), ptyLayer = Layer.succeed(Pty.Service, Pty.Service.of({

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/server",
-  "version": "2.0.4",
+  "version": "2.0.6",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -30,17 +30,17 @@
   "dependencies": {
     "@effect/platform-node": "4.0.0-rc.112",
     "@effect/platform-node-shared": "4.0.0-rc.112",
-    "@opencode/core": "2.0.4",
-    "@opencode/protocol": "2.0.4",
-    "@opencode/schema": "2.0.4",
-    "@opencode/simulation": "2.0.4",
-    "@opencode/util": "2.0.4",
+    "@opencode/core": "2.0.6",
+    "@opencode/protocol": "2.0.6",
+    "@opencode/schema": "2.0.6",
+    "@opencode/simulation": "2.0.6",
+    "@opencode/util": "2.0.6",
     "drizzle-orm": "1.0.0-rc.5-169397b",
     "effect": "4.0.0-rc.112"
   },
   "devDependencies": {
-    "@opencode/client": "2.0.4",
-    "@opencode/plugin": "2.0.4",
+    "@opencode/client": "2.0.6",
+    "@opencode/plugin": "2.0.6",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.4.0",
     "@typescript/native-preview": "7.0.0-dev.20251207.1"