@olares/lares-core 0.15.4 → 0.15.6

package/larepass/host.js

@@ -45,6 +45,23 @@ export function hostConfigFromEnv(env = {}) {
   };
 }
 
+/**
+ * Every key the host may hand down. The list is canonical: a host spreads these
+ * onto the components as props and `createHostClient` reads them back off the
+ * object, so a key that exists in one place and not the other is dropped in
+ * silence — which is how `socketProtocol` shipped inert once already.
+ */
+export const HOST_PORT_KEYS = ["baseUrl", "proxyPrefix", "env", "request", "socketProtocol"];
+
+/** Collect the port keys off any carrier (a component instance included). */
+export function pickHostPorts(source = {}) {
+  const ports = {};
+  for (const key of HOST_PORT_KEYS) {
+    ports[key] = source[key];
+  }
+  return ports;
+}
+
 /** Resolve the live Host origin. Explicit baseUrl/proxyPrefix win over env. */
 export function hostTarget(ports = {}) {
   const fromEnv = hostConfigFromEnv(ports.env);

package/larepass/mux.js

@@ -1,3 +1,5 @@
+import { normalizeQueueItems } from "./queue.js";
+
 export const MUX_PATH = "/api/events.mux";
 
 export const MUX_FETCH_HEADERS = {
@@ -63,6 +65,22 @@ export function classifyMuxEnvelope(envelope) {
       event: frame.view ? { ...frame.event, view: frame.view } : frame.event,
     };
   }
+  if (frame.type === "session/queue") {
+    return {
+      kind: "queue",
+      sessionId,
+      items: normalizeQueueItems(frame.items),
+    };
+  }
+  if (frame.type === "session/projection" && typeof frame.key === "string") {
+    return {
+      kind: "projection",
+      sessionId,
+      key: frame.key,
+      value: frame.value,
+      seq: frame.seq,
+    };
+  }
   if (frame.type === "question/requested") {
     return {
       kind: "question",
@@ -71,6 +89,25 @@ export function classifyMuxEnvelope(envelope) {
       questions: Array.isArray(frame.questions) ? frame.questions : [],
     };
   }
+  if (frame.type === "approval/requested") {
+    return {
+      kind: "approval",
+      sessionId,
+      rpcId,
+      approvalId: frame.approvalId,
+      toolName: frame.toolName,
+      callId: frame.callId,
+      reason: frame.reason,
+    };
+  }
+  if (frame.type === "approval/resolved") {
+    return {
+      kind: "approval-resolved",
+      sessionId,
+      approvalId: frame.approvalId,
+      outcome: frame.outcome,
+    };
+  }
   if (frame.type === "question/resolved") {
     return {
       kind: "question-resolved",

package/larepass/permissions.js

@@ -0,0 +1,56 @@
+/**
+ * The session's permission preset: which sandbox and approval policy its tools
+ * run under.
+ *
+ * The host publishes the effective preset and the offered options as the
+ * `permissions` session projection, and switching is the `/permission <name>`
+ * command — there is no dedicated RPC. Preset names arrive as the kebab keys
+ * the deployment declares (`workspace-write`), never as display copy, because
+ * the wire carries no locale; the dictionary below the `permission.` prefix
+ * owns the words and this module falls back to title case for a preset the
+ * client has never heard of.
+ */
+
+/**
+ * @param {unknown} row - a session summary or a raw `projections` block owner.
+ * @returns {{ options: Array<{ value: string, name?: string, description?: string }>, currentValue: string } | null}
+ */
+export function permissionSelect(row) {
+  const select = row?.permissions ?? row?.projections?.values?.permissions;
+  const options = (Array.isArray(select?.options) ? select.options : []).filter((option) => option?.value);
+  if (options.length === 0) return null;
+  return { options, currentValue: String(select?.currentValue || "") };
+}
+
+export function permissionOption(select, value = select?.currentValue) {
+  return select?.options.find((option) => option.value === value) ?? null;
+}
+
+function titleCase(name) {
+  return String(name)
+    .split(/[-_\s]+/)
+    .filter(Boolean)
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(" ");
+}
+
+export function presetLabel(t, option) {
+  const value = option?.value || "";
+  if (!value) return "";
+  const key = `permission.${value}`;
+  const text = t(key);
+  return text === key ? titleCase(option.name || value) : text;
+}
+
+export function presetDescription(t, option) {
+  const value = option?.value || "";
+  if (!value) return "";
+  const key = `permission.${value}.hint`;
+  const text = t(key);
+  return text === key ? String(option.description || "") : text;
+}
+
+/** The line the host parses as a preset switch. */
+export function permissionLine(value) {
+  return `/permission ${value}`;
+}

package/larepass/queue.js

@@ -0,0 +1,33 @@
+import { textFromBlocks } from "./transcript.js";
+
+function previewOf(text) {
+  return String(text ?? "").replace(/\s+/g, " ").trim();
+}
+
+function textOf(row) {
+  if (row.text === null) return null;
+  if (typeof row.text === "string") return row.text;
+  const content = Array.isArray(row.content) ? row.content : [];
+  const text = textFromBlocks(content);
+  if (text) return text;
+  return content.some((block) => block?.type && block.type !== "text") ? null : "";
+}
+
+/**
+ * Host queue rows carry `content` plus optional `preview`/`text`. The dock
+ * edits only a single text block; image-only rows stay non-editable.
+ */
+export function normalizeQueueItems(items) {
+  return (Array.isArray(items) ? items : []).flatMap((row) => {
+    if (!row || typeof row.id !== "string" || !row.id) return [];
+    const content = Array.isArray(row.content) ? row.content : [];
+    const text = textOf(row);
+    return [{
+      id: row.id,
+      placement: row.placement === "queued" ? "queued" : String(row.placement || "queued"),
+      content,
+      text,
+      preview: typeof row.preview === "string" && row.preview ? row.preview : previewOf(text),
+    }];
+  });
+}

package/larepass/references.js

@@ -0,0 +1,101 @@
+export const REFERENCES_PATH = "/api/lares/references";
+
+export function referencesUrl(sessionId, query = "") {
+  const params = new URLSearchParams();
+  if (sessionId) params.set("sessionId", sessionId);
+  if (query) params.set("query", query);
+  const suffix = params.toString();
+  return suffix ? `${REFERENCES_PATH}?${suffix}` : REFERENCES_PATH;
+}
+
+export function activeReferenceToken(draft, caret = String(draft ?? "").length) {
+  const text = String(draft ?? "");
+  const end = Math.max(0, Math.min(Number(caret) || 0, text.length));
+  const prefix = text.slice(0, end);
+  const match = prefix.match(/(?:^|\s)(@(?:"[^"]*|[^\s]*))$/u);
+  if (!match) return null;
+  const token = match[1];
+  const start = end - token.length;
+  if (token.startsWith('@"')) {
+    const query = token.slice(2);
+    if (query.includes('"')) return null;
+    return { start, end, query, quoted: true };
+  }
+  const query = token.slice(1);
+  if (/\s/.test(query)) return null;
+  return { start, end, query, quoted: false };
+}
+
+export function formatFileMention(candidate, preserveQuote = false) {
+  if (!candidate || typeof candidate.path !== "string") return null;
+  const directory = candidate.kind === "directory";
+  const path = directory ? `${candidate.path.replace(/\/$/, "")}/` : candidate.path;
+  if (/[\u0000-\u001f\u007f-\u009f"]/u.test(path)) return null;
+  if (!(preserveQuote || /\s/u.test(path))) return `@${path}`;
+  return directory ? `@"${path}` : `@"${path}"`;
+}
+
+export function normalizeReferenceCandidates(body, preserveQuote = false) {
+  const files = (Array.isArray(body?.files) ? body.files : []).flatMap((candidate) => {
+    const mention = formatFileMention(candidate, preserveQuote);
+    if (!mention) return [];
+    const directory = candidate.kind === "directory";
+    const label = candidate.path.slice(candidate.path.lastIndexOf("/") + 1) || candidate.path;
+    return [{
+      id: `file:${candidate.path}:${directory ? "d" : "f"}`,
+      kind: directory ? "directory" : "file",
+      label: `${label}${directory ? "/" : ""}`,
+      description: candidate.path,
+      mention,
+      continuation: directory,
+    }];
+  });
+  const sessions = (Array.isArray(body?.sessions) ? body.sessions : []).flatMap((candidate) => {
+    if (typeof candidate?.mention !== "string" || !candidate.mention) return [];
+    return [{
+      id: `session:${candidate.sessionId || candidate.mention}`,
+      kind: "session",
+      label: candidate.label || candidate.sessionId || candidate.mention,
+      description: candidate.cwd || candidate.sessionId || "",
+      mention: candidate.mention,
+      continuation: false,
+    }];
+  });
+  return [...files, ...sessions];
+}
+
+function base64Url(value) {
+  const bytes = new TextEncoder().encode(JSON.stringify(value));
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+
+export function sessionReferenceCandidates(sessions, currentSessionId, query = "") {
+  const needle = String(query).toLocaleLowerCase();
+  return (Array.isArray(sessions) ? sessions : []).flatMap((session) => {
+    if (!session?.sessionId || session.sessionId === currentSessionId) return [];
+    const label = String(session.title || session.sessionId);
+    const haystack = `${label}\n${session.sessionId}\n${session.cwd || ""}`.toLocaleLowerCase();
+    if (needle && !haystack.includes(needle)) return [];
+    const escaped = label.replace(/[\\\]]/gu, (match) => `\\${match}`);
+    return [{
+      id: `session:${session.sessionId}`,
+      kind: "session",
+      label,
+      description: session.cwd || session.sessionId,
+      mention: `@[${escaped}](dsh-session:${base64Url(session.sessionId)})`,
+      continuation: false,
+    }];
+  });
+}
+
+export function insertReference(draft, token, candidate) {
+  const text = String(draft ?? "");
+  const suffix = candidate.continuation || /\s/.test(text[token.end] ?? "") ? "" : " ";
+  const next = `${text.slice(0, token.start)}${candidate.mention}${suffix}${text.slice(token.end)}`;
+  return {
+    draft: next,
+    caret: token.start + candidate.mention.length + suffix.length,
+  };
+}

package/larepass/rpc.js

@@ -50,11 +50,14 @@ export function unwrapServerResponse(body) {
   return { ok: false, rpcId: body.rpcId, error: { code: "invalid-envelope", message: "invalid rpc envelope" } };
 }
 
-export function promptPayload(sessionId, text, timeZone) {
+export function promptPayload(sessionId, textOrContent, timeZone, mode = "queue") {
+  const content = Array.isArray(textOrContent)
+    ? textOrContent
+    : [{ type: "text", text: String(textOrContent ?? "") }];
   return {
     sessionId,
-    mode: "queue",
-    content: [{ type: "text", text: String(text ?? "") }],
+    mode: mode === "steer" ? "steer" : "queue",
+    content,
     ...(timeZone ? { clientTimeZone: timeZone } : {}),
   };
 }