saeeol 1.4.2 → 1.4.3

package/src/question/index.ts

@@ -1,269 +0,0 @@
-import { Deferred, Effect, Layer, Schema, Context } from "effect"
-import { Bus } from "@/bus"
-import { BusEvent } from "@/bus/bus-event"
-import { InstanceState } from "@/effect/instance-state"
-import { SessionID, MessageID } from "@/session/schema"
-import { zod } from "@/util/effect-zod"
-import * as Log from "@saeeol/core/util/log"
-import { withStatics } from "@/util/schema"
-import { QuestionID } from "./schema"
-import { makeRuntime } from "@/effect/run-service" 
-import { SaeeolQuestion } from "@/saeeol/question" 
-
-const log = Log.create({ service: "question" })
-
-// Schemas
-
-export class Option extends Schema.Class<Option>("QuestionOption")({
-  label: Schema.String.annotate({
-    description: "Display text (1-5 words, concise)",
-  }),
-  description: Schema.String.annotate({
-    description: "Explanation of choice",
-  }),
-  // replying with the canonical English label (backend matches on `label`).
-  labelKey: Schema.optional(Schema.String).annotate({
-    description: "Optional i18n key for the label; clients translate and still reply with `label`",
-  }),
-  descriptionKey: Schema.optional(Schema.String).annotate({
-    description: "Optional i18n key for the description",
-  }),
-  // when this option is selected (before the reply is confirmed by the server).
-  mode: Schema.optional(Schema.String).annotate({
-    description: "Optional agent/mode name to pre-select in the UI when this option is picked",
-  }),
-}) {
-  static readonly zod = zod(this)
-}
-
-const base = {
-  question: Schema.String.annotate({
-    description: "Complete question",
-  }),
-  header: Schema.String.annotate({
-    description: "Very short label (max 30 chars)",
-  }),
-  options: Schema.Array(Option).annotate({
-    description: "Available choices",
-  }),
-  multiple: Schema.optional(Schema.Boolean).annotate({
-    description: "Allow selecting multiple choices",
-  }),
-  questionKey: Schema.optional(Schema.String).annotate({
-    description: "Optional i18n key for the question text; clients fall back to `question` when missing",
-  }),
-  headerKey: Schema.optional(Schema.String).annotate({
-    description: "Optional i18n key for the header; clients fall back to `header` when missing",
-  }),
-}
-
-export class Info extends Schema.Class<Info>("QuestionInfo")({
-  ...base,
-  custom: Schema.optional(Schema.Boolean).annotate({
-    description: "Allow typing a custom answer (default: true)",
-  }),
-}) {
-  static readonly zod = zod(this)
-}
-
-export class Prompt extends Schema.Class<Prompt>("QuestionPrompt")(base) {
-  static readonly zod = zod(this)
-}
-
-export class Tool extends Schema.Class<Tool>("QuestionTool")({
-  messageID: MessageID,
-  callID: Schema.String,
-}) {
-  static readonly zod = zod(this)
-}
-
-export class Request extends Schema.Class<Request>("QuestionRequest")({
-  id: QuestionID,
-  sessionID: SessionID,
-  questions: Schema.Array(Info).annotate({
-    description: "Questions to ask",
-  }),
-  blocking: Schema.optional(Schema.Boolean).annotate({
-    description: "Whether this question blocks prompt input (default: true)",
-  }),
-  tool: Schema.optional(Tool),
-}) {
-  static readonly zod = zod(this)
-}
-
-export const Answer = Schema.Array(Schema.String)
-  .annotate({ identifier: "QuestionAnswer" })
-  .pipe(withStatics((s) => ({ zod: zod(s) })))
-export type Answer = Schema.Schema.Type<typeof Answer>
-
-export class Reply extends Schema.Class<Reply>("QuestionReply")({
-  answers: Schema.Array(Answer).annotate({
-    description: "User answers in order of questions (each answer is an array of selected labels)",
-  }),
-}) {
-  static readonly zod = zod(this)
-}
-
-class Replied extends Schema.Class<Replied>("QuestionReplied")({
-  sessionID: SessionID,
-  requestID: QuestionID,
-  answers: Schema.Array(Answer),
-}) {}
-
-class Rejected extends Schema.Class<Rejected>("QuestionRejected")({
-  sessionID: SessionID,
-  requestID: QuestionID,
-}) {}
-
-export const Event = {
-  Asked: BusEvent.define("question.asked", Request),
-  Replied: BusEvent.define("question.replied", Replied),
-  Rejected: BusEvent.define("question.rejected", Rejected),
-}
-
-export class RejectedError extends Schema.TaggedErrorClass<RejectedError>()("QuestionRejectedError", {}) {
-  override get message() {
-    return "The user dismissed this question"
-  }
-}
-
-interface PendingEntry {
-  info: Request
-  deferred: Deferred.Deferred<ReadonlyArray<Answer>, RejectedError>
-}
-
-interface State {
-  pending: Map<QuestionID, PendingEntry>
-}
-
-// Service
-
-export interface Interface {
-  readonly ask: (input: {
-    sessionID: SessionID
-    questions: ReadonlyArray<Info>
-    blocking?: boolean 
-    tool?: Tool
-  }) => Effect.Effect<ReadonlyArray<Answer>, RejectedError>
-  readonly reply: (input: { requestID: QuestionID; answers: ReadonlyArray<Answer> }) => Effect.Effect<void>
-  readonly reject: (requestID: QuestionID) => Effect.Effect<void>
-  readonly list: () => Effect.Effect<ReadonlyArray<Request>>
-  readonly dismissAll: (sessionID: SessionID) => Effect.Effect<void> 
-}
-
-export class Service extends Context.Service<Service, Interface>()("@saeeol/Question") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const bus = yield* Bus.Service
-    const state = yield* InstanceState.make<State>(
-      Effect.fn("Question.state")(function* () {
-        const state = {
-          pending: new Map<QuestionID, PendingEntry>(),
-        }
-
-        yield* Effect.addFinalizer(() =>
-          Effect.gen(function* () {
-            for (const item of state.pending.values()) {
-              yield* Deferred.fail(item.deferred, new RejectedError())
-            }
-            state.pending.clear()
-          }),
-        )
-
-        return state
-      }),
-    )
-
-    const ask = Effect.fn("Question.ask")(function* (input: {
-      sessionID: SessionID
-      questions: ReadonlyArray<Info>
-      blocking?: boolean 
-      tool?: Tool
-    }) {
-      const pending = (yield* InstanceState.get(state)).pending
-      const id = QuestionID.ascending()
-      log.info("asking", { id, questions: input.questions.length })
-
-      const deferred = yield* Deferred.make<ReadonlyArray<Answer>, RejectedError>()
-      const info = Schema.decodeUnknownSync(Request)({
-        id,
-        sessionID: input.sessionID,
-        questions: input.questions,
-        blocking: input.blocking, 
-        tool: input.tool,
-      })
-      yield* SaeeolQuestion.guardFollowup(input.sessionID, () => new RejectedError())
-
-      pending.set(id, { info, deferred })
-      yield* bus.publish(Event.Asked, info)
-
-      return yield* Effect.ensuring(
-        Deferred.await(deferred),
-        Effect.sync(() => {
-          pending.delete(id)
-        }),
-      )
-    })
-
-    const reply = Effect.fn("Question.reply")(function* (input: {
-      requestID: QuestionID
-      answers: ReadonlyArray<Answer>
-    }) {
-      const pending = (yield* InstanceState.get(state)).pending
-      const existing = pending.get(input.requestID)
-      if (!existing) {
-        log.warn("reply for unknown request", { requestID: input.requestID })
-        return
-      }
-      pending.delete(input.requestID)
-      log.info("replied", { requestID: input.requestID, answers: input.answers })
-      yield* bus.publish(Event.Replied, {
-        sessionID: existing.info.sessionID,
-        requestID: existing.info.id,
-        answers: input.answers.map((a) => [...a]),
-      })
-      yield* Deferred.succeed(existing.deferred, input.answers)
-    })
-
-    const reject = Effect.fn("Question.reject")(function* (requestID: QuestionID) {
-      const pending = (yield* InstanceState.get(state)).pending
-      const existing = pending.get(requestID)
-      if (!existing) {
-        log.warn("reject for unknown request", { requestID })
-        return
-      }
-      pending.delete(requestID)
-      log.info("rejected", { requestID })
-      yield* bus.publish(Event.Rejected, {
-        sessionID: existing.info.sessionID,
-        requestID: existing.info.id,
-      })
-      yield* Deferred.fail(existing.deferred, new RejectedError())
-    })
-
-    const list = Effect.fn("Question.list")(function* () {
-      const pending = (yield* InstanceState.get(state)).pending
-      return Array.from(pending.values(), (x) => x.info)
-    })
-    const dismissAll = SaeeolQuestion.makeDismissAll({
-      state,
-      publishRejected: (entry) =>
-        bus.publish(Event.Rejected, { sessionID: entry.info.sessionID, requestID: entry.info.id }),
-      makeError: () => new RejectedError(),
-    })
-
-    return Service.of({ ask, reply, reject, list, dismissAll }) 
-  }),
-)
-
-export const defaultLayer = layer.pipe(Layer.provide(Bus.layer))
-const { runPromise } = makeRuntime(Service, defaultLayer)
-export const list = () => runPromise((svc) => svc.list())
-export const ask = (input: Parameters<Interface["ask"]>[0]) => runPromise((svc) => svc.ask(input))
-export const reply = (input: Parameters<Interface["reply"]>[0]) => runPromise((svc) => svc.reply(input))
-export const reject = (requestID: QuestionID) => runPromise((svc) => svc.reject(requestID))
-export const dismissAll = (sessionID: string) => runPromise((svc) => svc.dismissAll(SessionID.make(sessionID)))
-
-export * as Question from "."

package/src/question/schema.ts

@@ -1,16 +0,0 @@
-import { Schema } from "effect"
-
-import { Identifier } from "@/id/id"
-import { zod, ZodOverride } from "@/util/effect-zod"
-import { Newtype } from "@/util/schema"
-
-export class QuestionID extends Newtype<QuestionID>()(
-  "QuestionID",
-  Schema.String.annotate({ [ZodOverride]: Identifier.schema("question") }),
-) {
-  static ascending(id?: string): QuestionID {
-    return this.make(Identifier.ascending("question", id))
-  }
-
-  static readonly zod = zod(this)
-}

package/src/saeeol-web-ui.gen.ts

@@ -1,33 +0,0 @@
-// Auto-generated by packages/web/generate.ts — DO NOT EDIT
-import { writeFileSync, mkdirSync, existsSync } from "node:fs"
-import { join, dirname } from "node:path"
-import { tmpdir } from "node:os"
-import { Buffer } from "node:buffer"
-
-const encoded: Record<string, string> = {
-  "assets/index--nIB0GG1.js": "(function(){const t=document.createElement("link").relList;if(t&&t.supports&&t.supports("modulepreload"))return;for(const i of document.querySelectorAll('link[rel="modulepreload"]'))s(i);new MutationObserver(i=>{for(const l of i)if(l.type==="childList")for(const o of l.addedNodes)o.tagName==="LINK"&&o.rel==="modulepreload"&&s(o)}).observe(document,{childList:!0,subtree:!0});function n(i){const l={};return i.integrity&&(l.integrity=i.integrity),i.referrerPolicy&&(l.referrerPolicy=i.referrerPolicy),i.crossOrigin==="use-credentials"?l.credentials="include":i.crossOrigin==="anonymous"?l.credentials="omit":l.credentials="same-origin",l}function s(i){if(i.ep)return;i.ep=!0;const l=n(i);fetch(i.href,l)}})();const ke=!1,Oe=(e,t)=>e===t,Ne=Symbol("solid-track"),Y={equals:Oe};let F=null,be=xe;const I=1,Z=2,ve={owned:null,cleanups:null,context:null,owner:null};var h=null;let oe=null,Ie=null,p=null,y=null,A=null,ne=0;function X(e,t){const n=p,s=h,i=e.length===0,l=t===void 0?s:t,o=i?ve:{owned:null,cleanups:null,context:l?l.context:null,owner:l},r=i?e:()=>e(()=>N(()=>G(o)));h=o,p=null;try{return H(r,!0)}finally{p=n,h=s}}function O(e,t){t=t?Object.assign({},Y,t):Y;const n={value:e,observers:null,observerSlots:null,comparator:t.equals||void 0},s=i=>(typeof i=="function"&&(i=i(n.value)),Ee(n,i));return[Se.bind(n),s]}function K(e,t,n){const s=se(e,t,!1,I);J(s)}function Le(e,t,n){be=Re;const s=se(e,t,!1,I);s.user=!0,A?A.push(s):J(s)}function q(e,t,n){n=n?Object.assign({},Y,n):Y;const s=se(e,t,!0,0);return s.observers=null,s.observerSlots=null,s.comparator=n.equals||void 0,J(s),Se.bind(s)}function N(e){if(p===null)return e();const t=p;p=null;try{return e()}finally{p=t}}function De(e){Le(()=>N(e))}function fe(e){return h===null||(h.cleanups===null?h.cleanups=[e]:h.cleanups.push(e)),e}function Be(e,t){F||(F=Symbol("error")),h=se(void 0,void 0,!0),h.context={...h.context,[F]:[t]};try{return e()}catch(n){ie(n)}finally{h=h.owner}}function Se(){if(this.sources&&this.state)if(this.state===I)J(this);else{const e=y;y=null,H(()=>ee(this),!1),y=e}if(p){const e=this.observers?this.observers.length:0;p.sources?(p.sources.push(this),p.sourceSlots.push(e)):(p.sources=[this],p.sourceSlots=[e]),this.observers?(this.observers.push(p),this.observerSlots.push(p.sources.length-1)):(this.observers=[p],this.observerSlots=[p.sources.length-1])}return this.value}function Ee(e,t,n){let s=e.value;return(!e.comparator||!e.comparator(s,t))&&(e.value=t,e.observers&&e.observers.length&&H(()=>{for(let i=0;i<e.observers.length;i+=1){const l=e.observers[i],o=oe&&oe.running;o&&oe.disposed.has(l),(o?!l.tState:!l.state)&&(l.pure?y.push(l):A.push(l),l.observers&&_e(l)),o||(l.state=I)}if(y.length>1e6)throw y=[],new Error},!1)),t}function J(e){if(!e.fn)return;G(e);const t=ne;Me(e,e.value,t)}function Me(e,t,n){let s;const i=h,l=p;p=h=e;try{s=e.fn(t)}catch(o){return e.pure&&(e.state=I,e.owned&&e.owned.forEach(G),e.owned=null),e.updatedAt=n+1,ie(o)}finally{p=l,h=i}(!e.updatedAt||e.updatedAt<=n)&&(e.updatedAt!=null&&"observers"in e?Ee(e,s):e.value=s,e.updatedAt=n)}function se(e,t,n,s=I,i){const l={fn:e,state:s,updatedAt:null,owned:null,sources:null,sourceSlots:null,cleanups:null,value:t,owner:h,context:h?h.context:null,pure:n};return h===null||h!==ve&&(h.owned?h.owned.push(l):h.owned=[l]),l}function z(e){if(e.state===0)return;if(e.state===Z)return ee(e);if(e.suspense&&N(e.suspense.inFallback))return e.suspense.effects.push(e);const t=[e];for(;(e=e.owner)&&(!e.updatedAt||e.updatedAt<ne);)e.state&&t.push(e);for(let n=t.length-1;n>=0;n--)if(e=t[n],e.state===I)J(e);else if(e.state===Z){const s=y;y=null,H(()=>ee(e,t[0]),!1),y=s}}function H(e,t){if(y)return e();let n=!1;t||(y=[]),A?n=!0:A=[],ne++;try{const s=e();return Pe(n),s}catch(s){n||(A=null),y=null,ie(s)}}function Pe(e){if(y&&(xe(y),y=null),e)return;const t=A;A=null,t.length&&H(()=>be(t),!1)}function xe(e){for(let t=0;t<e.length;t++)z(e[t])}function Re(e){let t,n=0;for(t=0;t<e.length;t++){const s=e[t];s.user?e[n++]=s:z(s)}for(t=0;t<n;t++)z(e[t])}function ee(e,t){e.state=0;for(let n=0;n<e.sources.length;n+=1){const s=e.sources[n];if(s.sources){const i=s.state;i===I?s!==t&&(!s.updatedAt||s.updatedAt<ne)&&z(s):i===Z&&ee(s,t)}}}function _e(e){for(let t=0;t<e.observers.length;t+=1){const n=e.observers[t];n.state||(n.state=Z,n.pure?y.push(n):A.push(n),n.observers&&_e(n))}}function G(e){let t;if(e.sources)for(;e.sources.length;){const n=e.sources.pop(),s=e.sourceSlots.pop(),i=n.observers;if(i&&i.length){const l=i.pop(),o=n.observerSlots.pop();s<i.length&&(l.sourceSlots[o]=s,i[s]=l,n.observerSlots[s]=o)}}if(e.tOwned){for(t=e.tOwned.length-1;t>=0;t--)G(e.tOwned[t]);delete e.tOwned}if(e.owned){for(t=e.owned.length-1;t>=0;t--)G(e.owned[t]);e.owned=null}if(e.cleanups){for(t=e.cleanups.length-1;t>=0;t--)e.cleanups[t]();e.cleanups=null}e.state=0}function je(e){return e instanceof Error?e:new Error(typeof e=="string"?e:"Unknown error",{cause:e})}function pe(e,t,n){try{for(const s of t)s(e)}catch(s){ie(s,n&&n.owner||null)}}function ie(e,t=h){const n=F&&t&&t.context&&t.context[F],s=je(e);if(!n)throw s;A?A.push({fn(){pe(s,n,t)},state:I}):pe(s,n,t)}const Ue=Symbol("fallback");function ge(e){for(let t=0;t<e.length;t++)e[t]()}function Ke(e,t,n={}){let s=[],i=[],l=[],o=0,r=t.length>1?[]:null;return fe(()=>ge(l)),()=>{let a=e()||[],f=a.length,d,c;return a[Ne],N(()=>{let $,T,E,j,P,b,v,u,m;if(f===0)o!==0&&(ge(l),l=[],s=[],i=[],o=0,r&&(r=[])),n.fallback&&(s=[Ue],i[0]=X(w=>(l[0]=w,n.fallback())),o=1);else if(o===0){for(i=new Array(f),c=0;c<f;c++)s[c]=a[c],i[c]=X(C);o=f}else{for(E=new Array(f),j=new Array(f),r&&(P=new Array(f)),b=0,v=Math.min(o,f);b<v&&s[b]===a[b];b++);for(v=o-1,u=f-1;v>=b&&u>=b&&s[v]===a[u];v--,u--)E[u]=i[v],j[u]=l[v],r&&(P[u]=r[v]);for($=new Map,T=new Array(u+1),c=u;c>=b;c--)m=a[c],d=$.get(m),T[c]=d===void 0?-1:d,$.set(m,c);for(d=b;d<=v;d++)m=s[d],c=$.get(m),c!==void 0&&c!==-1?(E[c]=i[d],j[c]=l[d],r&&(P[c]=r[d]),c=T[c],$.set(m,c)):l[d]();for(c=b;c<f;c++)c in E?(i[c]=E[c],l[c]=j[c],r&&(r[c]=P[c],r[c](c))):i[c]=X(C);i=i.slice(0,o=f),s=a.slice(0)}return i});function C($){if(l[c]=$,r){const[T,E]=O(c);return r[c]=E,t(a[c],T)}return t(a[c])}}}function B(e,t){return N(()=>e(t||{}))}const Ve=e=>`Stale read from <${e}>.`;function me(e){const t="fallback"in e&&{fallback:()=>e.fallback};return q(Ke(()=>e.each,e.children,t||void 0))}function ce(e){const t=e.keyed,n=q(()=>e.when,void 0,void 0),s=t?n:q(n,void 0,{equals:(i,l)=>!i==!l});return q(()=>{const i=s();if(i){const l=e.children;return typeof l=="function"&&l.length>0?N(()=>l(t?i:()=>{if(!N(s))throw Ve("Show");return n()})):l}return e.fallback},void 0,void 0)}let W;function Fe(e){let t;const[n,s]=O(t,void 0);return W||(W=new Set),W.add(s),fe(()=>W.delete(s)),q(()=>{let i;if(i=n()){const l=e.fallback;return typeof l=="function"&&l.length?N(()=>l(i,()=>s())):l}return Be(()=>e.children,s)},void 0,void 0)}function qe(e,t,n){let s=n.length,i=t.length,l=s,o=0,r=0,a=t[i-1].nextSibling,f=null;for(;o<i||r<l;){if(t[o]===n[r]){o++,r++;continue}for(;t[i-1]===n[l-1];)i--,l--;if(i===o){const d=l<s?r?n[r-1].nextSibling:n[l-r]:a;for(;r<l;)e.insertBefore(n[r++],d)}else if(l===r)for(;o<i;)(!f||!f.has(t[o]))&&t[o].remove(),o++;else if(t[o]===n[l-1]&&n[r]===t[i-1]){const d=t[--i].nextSibling;e.insertBefore(n[r++],t[o++].nextSibling),e.insertBefore(n[--l],d),t[i]=n[l]}else{if(!f){f=new Map;let c=r;for(;c<l;)f.set(n[c],c++)}const d=f.get(t[o]);if(d!=null)if(r<d&&d<l){let c=o,C=1,$;for(;++c<i&&c<l&&!(($=f.get(t[c]))==null||$!==d+C);)C++;if(C>d-r){const T=t[o];for(;r<d;)e.insertBefore(n[r++],T)}else e.replaceChild(n[r++],t[o++])}else o++;else t[o++].remove()}}}const ye="_$DX_DELEGATE";function Ge(e,t,n,s={}){let i;return X(l=>{i=l,t===document?e():S(t,e(),t.firstChild?null:void 0,n)},s.owner),()=>{i(),t.textContent=""}}function M(e,t,n,s){let i;const l=()=>{const r=document.createElement("template");return r.innerHTML=e,r.content.firstChild},o=()=>(i||(i=l())).cloneNode(!0);return o.cloneNode=o,o}function Ae(e,t=window.document){const n=t[ye]||(t[ye]=new Set);for(let s=0,i=e.length;s<i;s++){const l=e[s];n.has(l)||(n.add(l),t.addEventListener(l,He))}}function Je(e,t){t==null?e.removeAttribute("class"):e.className=t}function we(e,t,n){return N(()=>e(t,n))}function S(e,t,n,s){if(n!==void 0&&!s&&(s=[]),typeof t!="function")return te(e,t,s,n);K(i=>te(e,t(),i,n),s)}function He(e){let t=e.target;const n=`$$${e.type}`,s=e.target,i=e.currentTarget,l=a=>Object.defineProperty(e,"target",{configurable:!0,value:a}),o=()=>{const a=t[n];if(a&&!t.disabled){const f=t[`${n}Data`];if(f!==void 0?a.call(t,f,e):a.call(t,e),e.cancelBubble)return}return t.host&&typeof t.host!="string"&&!t.host._$host&&t.contains(e.target)&&l(t.host),!0},r=()=>{for(;o()&&(t=t._$host||t.parentNode||t.host););};if(Object.defineProperty(e,"currentTarget",{configurable:!0,get(){return t||document}}),e.composedPath){const a=e.composedPath();l(a[0]);for(let f=0;f<a.length-2&&(t=a[f],!!o());f++){if(t._$host){t=t._$host,r();break}if(t.parentNode===i)break}}else r();l(s)}function te(e,t,n,s,i){for(;typeof n=="function";)n=n();if(t===n)return n;const l=typeof t,o=s!==void 0;if(e=o&&n[0]&&n[0].parentNode||e,l==="string"||l==="number"){if(l==="number"&&(t=t.toString(),t===n))return n;if(o){let r=n[0];r&&r.nodeType===3?r.data!==t&&(r.data=t):r=document.createTextNode(t),n=U(e,n,s,r)}else n!==""&&typeof n=="string"?n=e.firstChild.data=t:n=e.textContent=t}else if(t==null||l==="boolean")n=U(e,n,s);else{if(l==="function")return K(()=>{let r=t();for(;typeof r=="function";)r=r();n=te(e,r,n,s)}),()=>n;if(Array.isArray(t)){const r=[],a=n&&Array.isArray(n);if(ae(r,t,n,i))return K(()=>n=te(e,r,n,s,!0)),()=>n;if(r.length===0){if(n=U(e,n,s),o)return n}else a?n.length===0?$e(e,r,s):qe(e,n,r):(n&&U(e),$e(e,r));n=r}else if(t.nodeType){if(Array.isArray(n)){if(o)return n=U(e,n,s,t);U(e,n,null,t)}else n==null||n===""||!e.firstChild?e.appendChild(t):e.replaceChild(t,e.firstChild);n=t}}return n}function ae(e,t,n,s){let i=!1;for(let l=0,o=t.length;l<o;l++){let r=t[l],a=n&&n[e.length],f;if(!(r==null||r===!0||r===!1))if((f=typeof r)=="object"&&r.nodeType)e.push(r);else if(Array.isArray(r))i=ae(e,r,a)||i;else if(f==="function")if(s){for(;typeof r=="function";)r=r();i=ae(e,Array.isArray(r)?r:[r],Array.isArray(a)?a:[a])||i}else e.push(r),i=!0;else{const d=String(r);a&&a.nodeType===3&&a.data===d?e.push(a):e.push(document.createTextNode(d))}}return i}function $e(e,t,n=null){for(let s=0,i=t.length;s<i;s++)e.insertBefore(t[s],n)}function U(e,t,n,s){if(n===void 0)return e.textContent="";const i=s||document.createTextNode("");if(t.length){let l=!1;for(let o=t.length-1;o>=0;o--){const r=t[o];if(i!==r){const a=r.parentNode===e;!l&&!o?a?e.replaceChild(i,r):e.insertBefore(i,n):a&&r.remove()}else l=!0}}else e.insertBefore(i,n);return[i]}function Qe(e){const t=e.replace(/\/+$/,"");async function n(s,i){return await fetch(`${t}${s}`,{...i,headers:{"Content-Type":"application/json",...i?.headers}})}return{url:t,fetch:n,async getSessions(){return(await n("/instance/sessions")).json()},async prompt(s,i){return n("/instance/prompt",{method:"POST",body:JSON.stringify({message:s,sessionId:i})})},events:{subscribe(s){const i=new EventSource(`${t}/global/event`);return i.onmessage=l=>{try{s(JSON.parse(l.data))}catch{}},i}}}}var We=M("<aside class=sidebar><div class=sidebar-header><button class=new-chat-btn>+ 새 대화</button></div><div class=sidebar-sessions>"),Xe=M("<div class=empty-state><div class=empty-logo>⬡</div><h2>SAEEOL</h2><p>AI 코딩 에이전트</p><div class=empty-hints><div class=hint>현재 프로젝트 구조를 설명해줘</div><div class=hint>README.md를 작성해줘</div><div class=hint>버그를 찾아서 수정해줘"),Ye=M('<div class="message message-assistant"><div class=message-avatar>⬡</div><div class=message-content><div class=typing-indicator><span></span><span></span><span>'),Ze=M('<div class=chat-layout><div class=chat-main><div class=messages><div></div></div><div class=input-area><div class=input-wrapper><textarea placeholder="메시지를 입력하세요..."rows=1></textarea><button class=send-btn>전송'),ze=M("<div class=session-item><span class=session-title>"),et=M("<div><div class=message-avatar></div><div class=message-content><div class=message-text></div><div class=message-time>");function tt(){const[e,t]=O([]),[n,s]=O(""),[i,l]=O(!1),[o]=O([]),[r,a]=O(null),[f,d]=O(!1),[c]=O(!0);let C,$,T;const E=()=>`${location.protocol}//${location.host}`;De(async()=>{try{T=Qe(E());const u=document.getElementById("connection-status");u&&(u.textContent="연결됨"),d(!0),await j()}catch{const m=document.getElementById("connection-status");m&&(m.textContent="연결 실패")}}),fe(()=>{});async function j(){try{const u=await fetch(`${E()}/workspace/list`);if(u.ok){const m=await u.json(),w=m.directories||m.workspaces||[]}}catch{}}async function P(){const u=n().trim();if(!u||i())return;const m={id:`u-${Date.now()}`,role:"user",content:u,timestamp:Date.now()};t(w=>[...w,m]),s(""),l(!0);try{const w={message:u};r()&&(w.sessionId=r());const x=await fetch(`${E()}/instance/prompt`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(w)});if(!x.ok){const le=await x.text();t(re=>[...re,{id:`e-${Date.now()}`,role:"assistant",content:`오류: ${x.status} ${le}`,timestamp:Date.now()}])}}catch(w){t(x=>[...x,{id:`e-${Date.now()}`,role:"assistant",content:`네트워크 오류: ${w.message}`,timestamp:Date.now()}])}finally{l(!1),b()}}function b(){requestAnimationFrame(()=>C?.scrollIntoView({behavior:"smooth"}))}function v(u){u.key==="Enter"&&!u.shiftKey&&(u.preventDefault(),P())}return(()=>{var u=Ze(),m=u.firstChild,w=m.firstChild,x=w.firstChild,le=w.nextSibling,re=le.firstChild,R=re.firstChild,ue=R.nextSibling;S(u,B(ce,{get when(){return c()},get children(){var g=We(),_=g.firstChild,k=_.firstChild,V=_.nextSibling;return k.$$click=()=>{t([]),a(null)},S(V,B(me,{get each(){return o()},children:L=>(()=>{var D=ze(),Q=D.firstChild;return D.$$click=()=>{a(L.id),navigate(`/s/${L.id}`)},S(Q,()=>L.title||"새 대화"),D})()})),g}}),m),S(w,B(ce,{get when(){return e().length===0},get children(){var g=Xe(),_=g.firstChild,k=_.nextSibling,V=k.nextSibling,L=V.nextSibling,D=L.firstChild,Q=D.nextSibling,Te=Q.nextSibling;return D.$$click=()=>s("현재 프로젝트 구조를 설명해줘"),Q.$$click=()=>s("README.md를 작성해줘"),Te.$$click=()=>s("버그를 찾아서 수정해줘"),g}}),x),S(w,B(me,{get each(){return e()},children:g=>(()=>{var _=et(),k=_.firstChild,V=k.nextSibling,L=V.firstChild,D=L.nextSibling;return S(k,()=>g.role==="user"?"👤":"⬡"),S(L,()=>g.content),S(D,()=>new Date(g.timestamp).toLocaleTimeString("ko-KR")),K(()=>Je(_,`message message-${g.role}`)),_})()}),x),S(w,B(ce,{get when(){return i()},get children(){return Ye()}}),x);var de=C;typeof de=="function"?we(de,x):C=x,R.$$keydown=v,R.$$input=g=>s(g.currentTarget.value);var he=$;return typeof he=="function"?we(he,R):$=R,ue.$$click=P,K(g=>{var _=!f(),k=!n().trim()||i()||!f();return _!==g.e&&(R.disabled=g.e=_),k!==g.t&&(ue.disabled=g.t=k),g},{e:void 0,t:void 0}),K(()=>R.value=n()),u})()}Ae(["click","input","keydown"]);var nt=M("<div class=app><nav class=topbar><div class=topbar-left><span class=logo>⬡ SAEEOL</span></div><div class=topbar-right><span class=status id=connection-status>연결 중...</span></div></nav><main class=main>"),st=M("<div class=error-screen><h2>오류 발생</h2><pre></pre><button>새로고침");function it(){return B(Fe,{fallback:e=>(()=>{var t=st(),n=t.firstChild,s=n.nextSibling,i=s.nextSibling;return S(s,()=>String(e)),i.$$click=()=>location.reload(),t})(),get children(){var e=nt(),t=e.firstChild,n=t.nextSibling;return S(n,B(tt,{})),e}})}Ae(["click"]);const Ce=document.getElementById("root");if(!Ce)throw new Error("Root element not found");Ge(()=>B(it,{}),Ce);
",
-  "assets/index-BAFkjvN0.css": "OnJvb3R7LS1iZzogIzBhMGEwYTstLWJnLXNlY29uZGFyeTogIzE0MTQxNDstLWJnLXRlcnRpYXJ5OiAjMWUxZTFlOy0tdGV4dDogI2UwZTBlMDstLXRleHQtZGltOiAjODg4Oy0tYWNjZW50OiAjZjk3MzE2Oy0tYWNjZW50LWhvdmVyOiAjZmI5MjNjOy0tYm9yZGVyOiAjMmEyYTJhOy0tdXNlci1iZzogIzFhMWEyZTstLWFzc2lzdGFudC1iZzogIzE0MTQxNDstLXJhZGl1czogOHB4fS5hcHB7ZGlzcGxheTpmbGV4O2ZsZXgtZGlyZWN0aW9uOmNvbHVtbjtoZWlnaHQ6MTAwdmg7b3ZlcmZsb3c6aGlkZGVufS50b3BiYXJ7ZGlzcGxheTpmbGV4O2FsaWduLWl0ZW1zOmNlbnRlcjtqdXN0aWZ5LWNvbnRlbnQ6c3BhY2UtYmV0d2VlbjtwYWRkaW5nOjAgMTZweDtoZWlnaHQ6NDRweDttaW4taGVpZ2h0OjQ0cHg7YmFja2dyb3VuZDp2YXIoLS1iZy1zZWNvbmRhcnkpO2JvcmRlci1ib3R0b206MXB4IHNvbGlkIHZhcigtLWJvcmRlcil9LnRvcGJhci1sZWZ0e2Rpc3BsYXk6ZmxleDthbGlnbi1pdGVtczpjZW50ZXI7Z2FwOjEycHh9LmxvZ297Zm9udC13ZWlnaHQ6NzAwO2ZvbnQtc2l6ZToxcmVtO2NvbG9yOnZhcigtLWFjY2VudCk7Y3Vyc29yOnBvaW50ZXJ9LnRvcGJhci1yaWdodHtkaXNwbGF5OmZsZXg7YWxpZ24taXRlbXM6Y2VudGVyO2dhcDo4cHh9LnN0YXR1c3tmb250LXNpemU6Ljc1cmVtO2NvbG9yOnZhcigtLXRleHQtZGltKX0ubWFpbntmbGV4OjE7b3ZlcmZsb3c6aGlkZGVufS5jaGF0LWxheW91dHtkaXNwbGF5OmZsZXg7aGVpZ2h0OjEwMCV9LnNpZGViYXJ7d2lkdGg6MjQwcHg7bWluLXdpZHRoOjI0MHB4O2JhY2tncm91bmQ6dmFyKC0tYmctc2Vjb25kYXJ5KTtib3JkZXItcmlnaHQ6MXB4IHNvbGlkIHZhcigtLWJvcmRlcik7ZGlzcGxheTpmbGV4O2ZsZXgtZGlyZWN0aW9uOmNvbHVtbn0uc2lkZWJhci1oZWFkZXJ7cGFkZGluZzoxMnB4fS5uZXctY2hhdC1idG57d2lkdGg6MTAwJTtwYWRkaW5nOjhweCAxMnB4O2JhY2tncm91bmQ6dmFyKC0tYWNjZW50KTtjb2xvcjojZmZmO2JvcmRlcjpub25lO2JvcmRlci1yYWRpdXM6dmFyKC0tcmFkaXVzKTtjdXJzb3I6cG9pbnRlcjtmb250LXNpemU6Ljg1cmVtO2ZvbnQtd2VpZ2h0OjYwMH0ubmV3LWNoYXQtYnRuOmhvdmVye2JhY2tncm91bmQ6dmFyKC0tYWNjZW50LWhvdmVyKX0uc2lkZWJhci1zZXNzaW9uc3tmbGV4OjE7b3ZlcmZsb3cteTphdXRvO3BhZGRpbmc6NHB4IDhweH0uc2Vzc2lvbi1pdGVte3BhZGRpbmc6OHB4IDEycHg7Ym9yZGVyLXJhZGl1czo2cHg7Y3Vyc29yOnBvaW50ZXI7bWFyZ2luLWJvdHRvbToycHg7Zm9udC1zaXplOi44NXJlbTtjb2xvcjp2YXIoLS10ZXh0LWRpbSk7d2hpdGUtc3BhY2U6bm93cmFwO292ZXJmbG93OmhpZGRlbjt0ZXh0LW92ZXJmbG93OmVsbGlwc2lzfS5zZXNzaW9uLWl0ZW06aG92ZXJ7YmFja2dyb3VuZDp2YXIoLS1iZy10ZXJ0aWFyeSk7Y29sb3I6dmFyKC0tdGV4dCl9LnNlc3Npb24tdGl0bGV7ZGlzcGxheTpibG9jaztvdmVyZmxvdzpoaWRkZW47dGV4dC1vdmVyZmxvdzplbGxpcHNpc30uY2hhdC1tYWlue2ZsZXg6MTtkaXNwbGF5OmZsZXg7ZmxleC1kaXJlY3Rpb246Y29sdW1uO21pbi13aWR0aDowfS5tZXNzYWdlc3tmbGV4OjE7b3ZlcmZsb3cteTphdXRvO3BhZGRpbmc6MjBweCAyNHB4fS5lbXB0eS1zdGF0ZXtkaXNwbGF5OmZsZXg7ZmxleC1kaXJlY3Rpb246Y29sdW1uO2FsaWduLWl0ZW1zOmNlbnRlcjtqdXN0aWZ5LWNvbnRlbnQ6Y2VudGVyO2hlaWdodDoxMDAlO3RleHQtYWxpZ246Y2VudGVyO2dhcDo4cHh9LmVtcHR5LWxvZ297Zm9udC1zaXplOjNyZW07Y29sb3I6dmFyKC0tYWNjZW50KX0uZW1wdHktc3RhdGUgaDJ7Zm9udC1zaXplOjEuNXJlbTtjb2xvcjp2YXIoLS10ZXh0KTttYXJnaW46MH0uZW1wdHktc3RhdGUgcHtjb2xvcjp2YXIoLS10ZXh0LWRpbSk7bWFyZ2luOjAgMCAyMHB4fS5lbXB0eS1oaW50c3tkaXNwbGF5OmZsZXg7ZmxleC1kaXJlY3Rpb246Y29sdW1uO2dhcDo4cHg7bWF4LXdpZHRoOjQwMHB4O3dpZHRoOjEwMCV9LmhpbnR7cGFkZGluZzoxMnB4IDE2cHg7YmFja2dyb3VuZDp2YXIoLS1iZy10ZXJ0aWFyeSk7Ym9yZGVyOjFweCBzb2xpZCB2YXIoLS1ib3JkZXIpO2JvcmRlci1yYWRpdXM6dmFyKC0tcmFkaXVzKTtjdXJzb3I6cG9pbnRlcjtmb250LXNpemU6Ljg1cmVtO2NvbG9yOnZhcigtLXRleHQtZGltKTt0ZXh0LWFsaWduOmxlZnR9LmhpbnQ6aG92ZXJ7Ym9yZGVyLWNvbG9yOnZhcigtLWFjY2VudCk7Y29sb3I6dmFyKC0tdGV4dCl9Lm1lc3NhZ2V7ZGlzcGxheTpmbGV4O2dhcDoxMnB4O21hcmdpbi1ib3R0b206MjBweDttYXgtd2lkdGg6ODAwcHh9Lm1lc3NhZ2UtdXNlciwubWVzc2FnZS1hc3Npc3RhbnR7ZmxleC1kaXJlY3Rpb246cm93fS5tZXNzYWdlLWF2YXRhcnt3aWR0aDozMnB4O2hlaWdodDozMnB4O21pbi13aWR0aDozMnB4O2JvcmRlci1yYWRpdXM6NTAlO2Rpc3BsYXk6ZmxleDthbGlnbi1pdGVtczpjZW50ZXI7anVzdGlmeS1jb250ZW50OmNlbnRlcjtmb250LXNpemU6MXJlbTtiYWNrZ3JvdW5kOnZhcigtLWJnLXRlcnRpYXJ5KX0ubWVzc2FnZS1jb250ZW50e2ZsZXg6MTttaW4td2lkdGg6MH0ubWVzc2FnZS11c2VyIC5tZXNzYWdlLWNvbnRlbnR7YmFja2dyb3VuZDp2YXIoLS11c2VyLWJnKTtwYWRkaW5nOjEwcHggMTRweDtib3JkZXItcmFkaXVzOjEycHggMTJweCAxMnB4IDRweH0ubWVzc2FnZS1hc3Npc3RhbnQgLm1lc3NhZ2UtY29udGVudHtiYWNrZ3JvdW5kOnZhcigtLWFzc2lzdGFudC1iZyk7cGFkZGluZzoxMHB4IDE0cHg7Ym9yZGVyLXJhZGl1czoxMnB4IDEycHggNHB4fS5tZXNzYWdlLXRleHR7d2hpdGUtc3BhY2U6cHJlLXdyYXA7d29yZC1icmVhazpicmVhay13b3JkO2xpbmUtaGVpZ2h0OjEuNjtmb250LXNpemU6LjlyZW19Lm1lc3NhZ2UtdGltZXtmb250LXNpemU6LjdyZW07Y29sb3I6dmFyKC0tdGV4dC1kaW0pO21hcmdpbi10b3A6NHB4O3RleHQtYWxpZ246cmlnaHR9LnR5cGluZy1pbmRpY2F0b3J7ZGlzcGxheTpmbGV4O2dhcDo0cHg7cGFkZGluZzo0cHggMH0udHlwaW5nLWluZGljYXRvciBzcGFue3dpZHRoOjhweDtoZWlnaHQ6OHB4O2JhY2tncm91bmQ6dmFyKC0tdGV4dC1kaW0pO2JvcmRlci1yYWRpdXM6NTAlO2FuaW1hdGlvbjp0eXBpbmcgMS40cyBpbmZpbml0ZX0udHlwaW5nLWluZGljYXRvciBzcGFuOm50aC1jaGlsZCgyKXthbmltYXRpb24tZGVsYXk6LjJzfS50eXBpbmctaW5kaWNhdG9yIHNwYW46bnRoLWNoaWxkKDMpe2FuaW1hdGlvbi1kZWxheTouNHN9QGtleWZyYW1lcyB0eXBpbmd7MCUsODAlLHRve29wYWNpdHk6LjM7dHJhbnNmb3JtOnNjYWxlKC44KX00MCV7b3BhY2l0eToxO3RyYW5zZm9ybTpzY2FsZSgxKX19LmlucHV0LWFyZWF7cGFkZGluZzoxMnB4IDI0cHggMTZweDtiYWNrZ3JvdW5kOnZhcigtLWJnKX0uaW5wdXQtd3JhcHBlcntkaXNwbGF5OmZsZXg7YWxpZ24taXRlbXM6ZmxleC1lbmQ7Z2FwOjhweDtiYWNrZ3JvdW5kOnZhcigtLWJnLXNlY29uZGFyeSk7Ym9yZGVyOjFweCBzb2xpZCB2YXIoLS1ib3JkZXIpO2JvcmRlci1yYWRpdXM6MTJweDtwYWRkaW5nOjhweCAxMnB4fS5pbnB1dC13cmFwcGVyIHRleHRhcmVhe2ZsZXg6MTtiYWNrZ3JvdW5kOm5vbmU7Ym9yZGVyOm5vbmU7Y29sb3I6dmFyKC0tdGV4dCk7Zm9udC1zaXplOi45cmVtO3Jlc2l6ZTpub25lO291dGxpbmU6bm9uZTttaW4taGVpZ2h0OjI0cHg7bWF4LWhlaWdodDoxMjBweDtsaW5lLWhlaWdodDoxLjU7Zm9udC1mYW1pbHk6aW5oZXJpdH0uaW5wdXQtd3JhcHBlciB0ZXh0YXJlYTo6cGxhY2Vob2xkZXJ7Y29sb3I6dmFyKC0tdGV4dC1kaW0pfS5pbnB1dC13cmFwcGVyIHRleHRhcmVhOmRpc2FibGVke29wYWNpdHk6LjV9LnNlbmQtYnRue3BhZGRpbmc6NnB4IDE2cHg7YmFja2dyb3VuZDp2YXIoLS1hY2NlbnQpO2NvbG9yOiNmZmY7Ym9yZGVyOm5vbmU7Ym9yZGVyLXJhZGl1czo2cHg7Y3Vyc29yOnBvaW50ZXI7Zm9udC1zaXplOi44NXJlbTtmb250LXdlaWdodDo2MDA7d2hpdGUtc3BhY2U6bm93cmFwfS5zZW5kLWJ0bjpob3Zlcjpub3QoOmRpc2FibGVkKXtiYWNrZ3JvdW5kOnZhcigtLWFjY2VudC1ob3Zlcil9LnNlbmQtYnRuOmRpc2FibGVke29wYWNpdHk6LjQ7Y3Vyc29yOm5vdC1hbGxvd2VkfS5lcnJvci1zY3JlZW57ZGlzcGxheTpmbGV4O2ZsZXgtZGlyZWN0aW9uOmNvbHVtbjthbGlnbi1pdGVtczpjZW50ZXI7anVzdGlmeS1jb250ZW50OmNlbnRlcjtoZWlnaHQ6MTAwJTtnYXA6MTZweDtwYWRkaW5nOjIwcHh9LmVycm9yLXNjcmVlbiBwcmV7YmFja2dyb3VuZDp2YXIoLS1iZy10ZXJ0aWFyeSk7cGFkZGluZzoxNnB4O2JvcmRlci1yYWRpdXM6dmFyKC0tcmFkaXVzKTttYXgtd2lkdGg6NjAwcHg7b3ZlcmZsb3c6YXV0bztjb2xvcjojZjg3MTcxO2ZvbnQtc2l6ZTouODVyZW19LmVycm9yLXNjcmVlbiBidXR0b257cGFkZGluZzo4cHggMjRweDtiYWNrZ3JvdW5kOnZhcigtLWFjY2VudCk7Y29sb3I6I2ZmZjtib3JkZXI6bm9uZTtib3JkZXItcmFkaXVzOnZhcigtLXJhZGl1cyk7Y3Vyc29yOnBvaW50ZXI7Zm9udC1zaXplOi45cmVtfQo=",
-  "index.html": "PCFET0NUWVBFIGh0bWw+CjxodG1sIGxhbmc9ImtvIj4KICA8aGVhZD4KICAgIDxtZXRhIGNoYXJzZXQ9IlVURi04IiAvPgogICAgPG1ldGEgbmFtZT0idmlld3BvcnQiIGNvbnRlbnQ9IndpZHRoPWRldmljZS13aWR0aCwgaW5pdGlhbC1zY2FsZT0xLjAiIC8+CiAgICA8dGl0bGU+U0FFRU9MPC90aXRsZT4KICAgIDxsaW5rIHJlbD0iaWNvbiIgdHlwZT0iaW1hZ2Uvc3ZnK3htbCIgaHJlZj0iL2Zhdmljb24uc3ZnIiAvPgogICAgPHN0eWxlPgogICAgICAqIHsgbWFyZ2luOiAwOyBwYWRkaW5nOiAwOyBib3gtc2l6aW5nOiBib3JkZXItYm94OyB9CiAgICAgIGh0bWwsIGJvZHksICNyb290IHsgaGVpZ2h0OiAxMDAlOyB3aWR0aDogMTAwJTsgb3ZlcmZsb3c6IGhpZGRlbjsgfQogICAgICBib2R5IHsgZm9udC1mYW1pbHk6IC1hcHBsZS1zeXN0ZW0sIEJsaW5rTWFjU3lzdGVtRm9udCwgJ1NlZ29lIFVJJywgUm9ib3RvLCBzYW5zLXNlcmlmOyBiYWNrZ3JvdW5kOiAjMGEwYTBhOyBjb2xvcjogI2UwZTBlMDsgfQogICAgICAjbG9hZGluZyB7IGRpc3BsYXk6IGZsZXg7IGFsaWduLWl0ZW1zOiBjZW50ZXI7IGp1c3RpZnktY29udGVudDogY2VudGVyOyBoZWlnaHQ6IDEwMCU7IH0KICAgICAgI2xvYWRpbmcgc3BhbiB7IGNvbG9yOiAjZjk3MzE2OyBmb250LXNpemU6IDEuMnJlbTsgfQogICAgPC9zdHlsZT4KICAgIDxzY3JpcHQgdHlwZT0ibW9kdWxlIiBjcm9zc29yaWdpbiBzcmM9Ii9hc3NldHMvaW5kZXgtLW5JQjBHRzEuanMiPjwvc2NyaXB0PgogICAgPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBjcm9zc29yaWdpbiBocmVmPSIvYXNzZXRzL2luZGV4LUJBRmtqdk4wLmNzcyI+CiAgPC9oZWFkPgogIDxib2R5PgogICAgPGRpdiBpZD0icm9vdCI+CiAgICAgIDxkaXYgaWQ9ImxvYWRpbmciPjxzcGFuPlNBRUVPTCDroZzrk5wg7KSRLi4uPC9zcGFuPjwvZGl2PgogICAgPC9kaXY+CiAgPC9ib2R5Pgo8L2h0bWw+Cg=="
-}
-
-const _dir = join(tmpdir(), "saeeol-web-ui")
-const _cache: Record<string, string> = {}
-
-const files: Record<string, string> = {}
-for (const key of Object.keys(encoded)) {
-  Object.defineProperty(files, key, {
-    get() {
-      if (_cache[key]) return _cache[key]
-      const p = join(_dir, key)
-      const d = dirname(p)
-      if (!existsSync(d)) mkdirSync(d, { recursive: true })
-      writeFileSync(p, Buffer.from(encoded[key], "base64"))
-      _cache[key] = p
-      return p
-    },
-    enumerable: true,
-    configurable: true,
-  })
-}
-
-export default files

package/src/server/adapter.bun.ts

@@ -1,44 +0,0 @@
-import type { Hono } from "hono"
-import { createBunWebSocket } from "hono/bun"
-import type { Adapter, FetchApp, Opts } from "./adapter"
-
-function listen(app: FetchApp, opts: Opts, websocket?: ReturnType<typeof createBunWebSocket>["websocket"]) {
-  const start = (port: number) => {
-    try {
-      if (websocket) {
-        return Bun.serve({ fetch: app.fetch, hostname: opts.hostname, idleTimeout: 0, websocket, port })
-      }
-      return Bun.serve({ fetch: app.fetch, hostname: opts.hostname, idleTimeout: 0, port })
-    } catch {
-      return
-    }
-  }
-  const server = opts.port === 0 ? (start(4096) ?? start(0)) : start(opts.port)
-  if (!server) {
-    throw new Error(`Failed to start server on port ${opts.port}`)
-  }
-  if (!server.port) {
-    throw new Error(`Failed to resolve server address for port ${opts.port}`)
-  }
-  return {
-    port: server.port,
-    stop(close?: boolean) {
-      return Promise.resolve(server.stop(close))
-    },
-  }
-}
-
-export const adapter: Adapter = {
-  create(app: Hono) {
-    const ws = createBunWebSocket()
-    return {
-      upgradeWebSocket: ws.upgradeWebSocket,
-      listen: (opts) => Promise.resolve(listen(app, opts, ws.websocket)),
-    }
-  },
-  createFetch(app) {
-    return {
-      listen: (opts) => Promise.resolve(listen(app, opts)),
-    }
-  },
-}

package/src/server/adapter.node.ts

@@ -1,73 +0,0 @@
-import { createAdaptorServer, type ServerType } from "@hono/node-server"
-import { createNodeWebSocket } from "@hono/node-ws"
-import type { Hono } from "hono"
-import type { Adapter, FetchApp, Opts } from "./adapter"
-
-async function listen(app: FetchApp, opts: Opts, inject?: (server: ServerType) => void) {
-  const start = (port: number) =>
-    new Promise<ServerType>((resolve, reject) => {
-      const server = createAdaptorServer({ fetch: app.fetch })
-      inject?.(server)
-      const fail = (err: Error) => {
-        cleanup()
-        reject(err)
-      }
-      const ready = () => {
-        cleanup()
-        resolve(server)
-      }
-      const cleanup = () => {
-        server.off("error", fail)
-        server.off("listening", ready)
-      }
-      server.once("error", fail)
-      server.once("listening", ready)
-      server.listen(port, opts.hostname)
-    })
-
-  const server = opts.port === 0 ? await start(4096).catch(() => start(0)) : await start(opts.port)
-  const addr = server.address()
-  if (!addr || typeof addr === "string") {
-    throw new Error(`Failed to resolve server address for port ${opts.port}`)
-  }
-
-  let closing: Promise<void> | undefined
-  return {
-    port: addr.port,
-    stop(close?: boolean) {
-      closing ??= new Promise<void>((resolve, reject) => {
-        server.close((err) => {
-          if (err) {
-            reject(err)
-            return
-          }
-          resolve()
-        })
-        if (close) {
-          if ("closeAllConnections" in server && typeof server.closeAllConnections === "function") {
-            server.closeAllConnections()
-          }
-          if ("closeIdleConnections" in server && typeof server.closeIdleConnections === "function") {
-            server.closeIdleConnections()
-          }
-        }
-      })
-      return closing
-    },
-  }
-}
-
-export const adapter: Adapter = {
-  create(app: Hono) {
-    const ws = createNodeWebSocket({ app })
-    return {
-      upgradeWebSocket: ws.upgradeWebSocket,
-      listen: (opts) => listen(app, opts, ws.injectWebSocket),
-    }
-  },
-  createFetch(app) {
-    return {
-      listen: (opts) => listen(app, opts),
-    }
-  },
-}

package/src/server/adapter.ts

@@ -1,26 +0,0 @@
-import type { Hono } from "hono"
-import type { UpgradeWebSocket } from "hono/ws"
-
-export type FetchApp = {
-  fetch(request: Request): Response | Promise<Response>
-}
-
-export type Opts = {
-  port: number
-  hostname: string
-}
-
-export type Listener = {
-  port: number
-  stop: (close?: boolean) => Promise<void>
-}
-
-export interface Runtime {
-  upgradeWebSocket: UpgradeWebSocket
-  listen(opts: Opts): Promise<Listener>
-}
-
-export interface Adapter {
-  create(app: Hono): Runtime
-  createFetch(app: FetchApp): Omit<Runtime, "upgradeWebSocket">
-}

package/src/server/backend.ts

@@ -1,32 +0,0 @@
-import { Flag } from "@saeeol/core/flag/flag"
-import { InstallationChannel, InstallationVersion } from "@saeeol/core/installation/version"
-
-export type Backend = "effect-httpapi" | "hono"
-
-export type Selection = {
-  backend: Backend
-  reason: "env" | "stable" | "explicit"
-}
-
-export type Attributes = ReturnType<typeof attributes>
-
-export function select(): Selection {
-  if (Flag.SAEEOL_EXPERIMENTAL_HTTPAPI) return { backend: "effect-httpapi", reason: "env" }
-  return { backend: "hono", reason: "stable" }
-}
-
-export function attributes(selection: Selection): Record<string, string> {
-  return {
-    "saeeol.server.backend": selection.backend,
-    "saeeol.server.backend.reason": selection.reason,
-    "saeeol.installation.channel": InstallationChannel,
-    "saeeol.installation.version": InstallationVersion,
-  }
-}
-
-export function force(selection: Selection, backend: Backend): Selection {
-  return {
-    backend,
-    reason: selection.backend === backend ? selection.reason : "explicit",
-  }
-}

package/src/server/cors.ts

@@ -1,17 +0,0 @@
-import * as SaeeolServer from "@/saeeol/server/server" 
-
-const saeeolOrigin = /^https:\/\/([a-z0-9-]+\.)*saeeol\.ai$/
-
-export type CorsOptions = { readonly cors?: ReadonlyArray<string> }
-
-export function isAllowedCorsOrigin(input: string | undefined, opts?: CorsOptions) {
-  if (!input) return true
-  if (input.startsWith("http://localhost:")) return true
-  if (input.startsWith("http://127.0.0.1:")) return true
-  if (input.startsWith("oc://renderer")) return true
-  if (input === "tauri://localhost" || input === "http://tauri.localhost" || input === "https://tauri.localhost")
-    return true
-  if (saeeolOrigin.test(input)) return true
-  if (SaeeolServer.corsOrigin(input)) return true
-  return opts?.cors?.includes(input) ?? false
-}

package/src/server/error.ts

@@ -1,36 +0,0 @@
-import { resolver } from "hono-openapi"
-import z from "zod"
-import { NotFoundError } from "@/storage/storage"
-
-export const ERRORS = {
-  400: {
-    description: "Bad request",
-    content: {
-      "application/json": {
-        schema: resolver(
-          z
-            .object({
-              data: z.any(),
-              errors: z.array(z.record(z.string(), z.any())),
-              success: z.literal(false),
-            })
-            .meta({
-              ref: "BadRequestError",
-            }),
-        ),
-      },
-    },
-  },
-  404: {
-    description: "Not found",
-    content: {
-      "application/json": {
-        schema: resolver(NotFoundError.Schema),
-      },
-    },
-  },
-} as const
-
-export function errors(...codes: number[]) {
-  return Object.fromEntries(codes.map((code) => [code, ERRORS[code as keyof typeof ERRORS]]))
-}

package/src/server/event.ts

@@ -1,8 +0,0 @@
-import { BusEvent } from "@/bus/bus-event"
-import { Schema } from "effect"
-
-export const Event = {
-  Connected: BusEvent.define("server.connected", Schema.Struct({})),
-  Disposed: BusEvent.define("global.disposed", Schema.Struct({})),
-  ConfigUpdated: BusEvent.define("global.config.updated", Schema.Struct({})),
-}