agent-sin 0.1.12 → 0.1.16

package/templates/even-g2-agent/src/main.ts

@@ -0,0 +1,539 @@
+import {
+  LAUNCH_SOURCE_GLASSES_MENU,
+  OsEventTypeList,
+  StartUpPageCreateResult,
+  waitForEvenAppBridge,
+  type EvenAppBridge,
+  type EvenHubEvent,
+} from "@evenrealities/even_hub_sdk";
+import { EMBEDDED_SERVER, EMBEDDED_TOKEN } from "./embedded-config";
+import "./style.css";
+
+const STORAGE_SERVER = "agent_sin_g2_server";
+const STORAGE_TOKEN = "agent_sin_g2_token";
+const IDLE_ACTIONS = ["Talk"] as const;
+const RECORDING_ACTIONS = ["Send", "Cancel"] as const;
+const THINKING_ACTIONS = ["Cancel"] as const;
+
+type ActionName = "Talk" | "Send" | "Cancel";
+
+function currentMenu(): readonly ActionName[] {
+  if (recording) return RECORDING_ACTIONS as readonly ActionName[];
+  if (thinking) return THINKING_ACTIONS as readonly ActionName[];
+  return IDLE_ACTIONS as readonly ActionName[];
+}
+
+const statusEl = document.querySelector<HTMLParagraphElement>("#status")!;
+const logEl = document.querySelector<HTMLPreElement>("#log")!;
+const settingsForm = document.querySelector<HTMLFormElement>("#settings")!;
+const textForm = document.querySelector<HTMLFormElement>("#textForm")!;
+const serverInput = document.querySelector<HTMLInputElement>("#serverUrl")!;
+const tokenInput = document.querySelector<HTMLInputElement>("#token")!;
+const textInput = document.querySelector<HTMLInputElement>("#textInput")!;
+
+let bridge: EvenAppBridge | null = null;
+let ws: WebSocket | null = null;
+let recording = false;
+let thinking = false;
+let ignoreNextReply = false;
+let audioChunks: Uint8Array[] = [];
+let glassesReady = false;
+let selectedActionIndex = 0;
+let glassesStatusText = "Agent ready";
+let pendingTranscript: string | null = null;
+
+void boot();
+
+async function boot(): Promise<void> {
+  const urlConfig = applyUrlConfig();
+  serverInput.value = localStorage.getItem(STORAGE_SERVER) || "";
+  tokenInput.value = localStorage.getItem(STORAGE_TOKEN) || "";
+  settingsForm.addEventListener("submit", (event) => {
+    event.preventDefault();
+    void saveSettings();
+  });
+  textForm.addEventListener("submit", (event) => {
+    event.preventDefault();
+    const text = textInput.value.trim();
+    if (!text) return;
+    textInput.value = "";
+    const sent = sendJson({ type: "message", text, input_mode: "text" });
+    appendLog(`G2: ${text}`);
+    if (sent) {
+      thinking = true;
+      void renderGlasses("Thinking...");
+    }
+  });
+
+  connect();
+  bridge = await waitForBridge(5000);
+  if (!bridge) {
+    setStatus(serverInput.value.trim() ? "Phone mode ready" : "Set server URL");
+    return;
+  }
+  if (urlConfig.server) await writeSetting(STORAGE_SERVER, urlConfig.server);
+  if (urlConfig.token) await writeSetting(STORAGE_TOKEN, urlConfig.token);
+  serverInput.value = await readSetting(STORAGE_SERVER);
+  tokenInput.value = await readSetting(STORAGE_TOKEN);
+  bridge.onLaunchSource((source) => {
+    if (source === LAUNCH_SOURCE_GLASSES_MENU) {
+      void startGlassesMode();
+    } else {
+      setStatus("Set server URL, then launch from glasses.");
+    }
+  });
+  bridge.onEvenHubEvent((event) => {
+    void handleEvenHubEvent(event);
+  });
+  connect();
+
+  // Fallback: the launch-source event may already have fired before our listener
+  // is registered when the webview is cold-started from the glasses menu. If the
+  // user has a server URL set, just bring up the glasses UI proactively.
+  const initialServer = await readSetting(STORAGE_SERVER);
+  if (initialServer && !glassesReady) {
+    void startGlassesMode();
+  }
+}
+
+function applyUrlConfig(): { server: string; token: string } {
+  const params = new URLSearchParams(window.location.search);
+  const hash = window.location.hash.startsWith("#")
+    ? new URLSearchParams(window.location.hash.slice(1))
+    : new URLSearchParams();
+  const server = (hash.get("server") || params.get("server") || hash.get("g2_server") || params.get("g2_server") || "").trim();
+  const token = (hash.get("token") || params.get("token") || hash.get("g2_token") || params.get("g2_token") || "").trim();
+  if (server) localStorage.setItem(STORAGE_SERVER, server);
+  if (token) localStorage.setItem(STORAGE_TOKEN, token);
+  if (server || token) {
+    appendLog("Configured from QR.");
+    setStatus("Configured from QR");
+    if (window.location.hash) {
+      history.replaceState(null, "", window.location.pathname + window.location.search);
+    }
+  }
+  // Fall back to build-time embedded values when localStorage is empty.
+  if (!localStorage.getItem(STORAGE_SERVER) && EMBEDDED_SERVER) {
+    localStorage.setItem(STORAGE_SERVER, EMBEDDED_SERVER);
+  }
+  if (!localStorage.getItem(STORAGE_TOKEN) && EMBEDDED_TOKEN) {
+    localStorage.setItem(STORAGE_TOKEN, EMBEDDED_TOKEN);
+  }
+  return { server, token };
+}
+
+async function waitForBridge(timeoutMs: number): Promise<EvenAppBridge | null> {
+  try {
+    return await Promise.race([
+      waitForEvenAppBridge(),
+      new Promise<null>((resolve) => setTimeout(() => resolve(null), timeoutMs)),
+    ]);
+  } catch {
+    return null;
+  }
+}
+
+async function saveSettings(): Promise<void> {
+  await writeSetting(STORAGE_SERVER, serverInput.value.trim());
+  await writeSetting(STORAGE_TOKEN, tokenInput.value.trim());
+  connect();
+  setStatus("Saved");
+}
+
+async function startGlassesMode(): Promise<void> {
+  if (!bridge) return;
+  const server = await readSetting(STORAGE_SERVER);
+  if (!server) {
+    await createOrUpdateGlasses("Open the phone app and set server URL.");
+    return;
+  }
+  connect();
+  await renderGlasses("Agent ready");
+}
+
+async function createOrUpdateGlasses(text: string): Promise<void> {
+  if (!bridge) return;
+  if (!glassesReady) {
+    const result = await bridge.createStartUpPageContainer({
+      containerTotalNum: 1,
+      textObject: [
+        {
+          xPosition: 8,
+          yPosition: 0,
+          width: 560,
+          height: 288,
+          paddingLength: 4,
+          containerID: 1,
+          containerName: "status",
+          content: text,
+          isEventCapture: 1,
+        },
+      ],
+    });
+    glassesReady = result === StartUpPageCreateResult.success || result === 0;
+    if (!glassesReady) {
+      setStatus(`Glasses UI failed: ${result}`);
+      return;
+    }
+  }
+  const content = text.slice(0, 1800);
+  await bridge.textContainerUpgrade({
+    containerID: 1,
+    containerName: "status",
+    contentOffset: 0,
+    contentLength: content.length,
+    content,
+  });
+}
+
+async function handleEvenHubEvent(event: EvenHubEvent): Promise<void> {
+  try {
+    if (event.audioEvent) {
+      if (recording) {
+        audioChunks.push(event.audioEvent.audioPcm);
+      }
+      return;
+    }
+
+    let eventType: OsEventTypeList | undefined;
+    try {
+      eventType = normalizeEventType(rawEventType(event));
+    } catch (error) {
+      appendLog(`G2 normalize error: ${safeError(error)}`);
+      eventType = undefined;
+    }
+
+    if (eventType === OsEventTypeList.SCROLL_TOP_EVENT) {
+      moveSelection(-1);
+      await renderGlasses(glassesStatusText);
+      return;
+    }
+    if (eventType === OsEventTypeList.SCROLL_BOTTOM_EVENT) {
+      moveSelection(1);
+      await renderGlasses(glassesStatusText);
+      return;
+    }
+    if (eventType === OsEventTypeList.DOUBLE_CLICK_EVENT) {
+      if (recording) {
+        await toggleRecording();
+      } else {
+        await shutdown();
+      }
+      return;
+    }
+    if (isClickEvent(event, eventType)) {
+      const action = selectedActionFromEvent(event);
+      await runAction(action);
+      return;
+    }
+    const sys = event.sysEvent;
+    if (
+      sys?.eventType === OsEventTypeList.ABNORMAL_EXIT_EVENT ||
+      sys?.eventType === OsEventTypeList.SYSTEM_EXIT_EVENT
+    ) {
+      await stopAudio();
+    }
+  } catch (error) {
+    appendLog(`G2 handler error: ${safeError(error)}`);
+  }
+}
+
+function safeError(error: unknown): string {
+  if (error instanceof Error) return `${error.name}: ${error.message}`;
+  try { return String(error); } catch { return "(unknown error)"; }
+}
+
+async function renderGlasses(text: string): Promise<void> {
+  glassesStatusText = text;
+  try {
+    await createOrUpdateGlasses(formatGlassesText(text));
+  } catch (error) {
+    appendLog(`renderGlasses error: ${safeError(error)}`);
+  }
+}
+
+function formatGlassesText(text: string): string {
+  const actions = currentMenu();
+  const menu = actions
+    .map((action, index) => {
+      const marker = index === selectedActionIndex ? ">" : " ";
+      return `${marker} ${action}`;
+    })
+    .join("\n");
+  return `${text}\n\n${menu}`;
+}
+
+function rawEventType(event: EvenHubEvent): unknown {
+  const loose = event as Record<string, any>;
+  const candidates = [
+    event.listEvent?.eventType,
+    event.textEvent?.eventType,
+    event.sysEvent?.eventType,
+    (event.listEvent as any)?.Event_Type,
+    (event.textEvent as any)?.Event_Type,
+    (event.sysEvent as any)?.Event_Type,
+    loose.eventType,
+    loose.Event_Type,
+    loose.type,
+    loose.data?.eventType,
+    loose.data?.Event_Type,
+    loose.jsonData?.eventType,
+    loose.jsonData?.Event_Type,
+  ];
+  for (const candidate of candidates) {
+    if (candidate !== undefined && candidate !== null && candidate !== "") return candidate;
+  }
+  return undefined;
+}
+
+function normalizeEventType(raw: unknown): OsEventTypeList | undefined {
+  if (typeof raw === "number") {
+    return Number.isInteger(raw) && raw >= 0 && raw <= 8 ? raw as OsEventTypeList : undefined;
+  }
+  if (typeof raw !== "string") return undefined;
+  const key = raw.split(".").pop()?.trim().toUpperCase().replace(/^OS_EVENT_TYPE_LIST_/, "") || "";
+  if (key === "CLICK") return OsEventTypeList.CLICK_EVENT;
+  if (key === "SCROLL_TOP") return OsEventTypeList.SCROLL_TOP_EVENT;
+  if (key === "SCROLL_BOTTOM") return OsEventTypeList.SCROLL_BOTTOM_EVENT;
+  if (key === "DOUBLE_CLICK") return OsEventTypeList.DOUBLE_CLICK_EVENT;
+  if (key === "ABNORMAL_EXIT") return OsEventTypeList.ABNORMAL_EXIT_EVENT;
+  if (key === "SYSTEM_EXIT") return OsEventTypeList.SYSTEM_EXIT_EVENT;
+  const value = (OsEventTypeList as Record<string, number | string>)[key];
+  return typeof value === "number" ? value as OsEventTypeList : undefined;
+}
+
+function isClickEvent(event: EvenHubEvent, eventType: OsEventTypeList | undefined): boolean {
+  if (eventType === OsEventTypeList.CLICK_EVENT) return true;
+  if (eventType !== undefined) return false;
+  if (event.listEvent || event.textEvent) return true;
+  const loose = event as Record<string, any>;
+  const eventSourceCandidates = [
+    event.sysEvent && (event.sysEvent as any).eventSource,
+    loose.eventSource,
+    loose.jsonData?.eventSource,
+    loose.jsondata?.eventSource,
+  ];
+  return eventSourceCandidates.some((value) => typeof value === "number" && value > 0);
+}
+
+function moveSelection(delta: number): void {
+  const actions = currentMenu();
+  selectedActionIndex = (selectedActionIndex + delta + actions.length) % actions.length;
+  appendLog(`Selected: ${actions[selectedActionIndex]}`);
+}
+
+function selectedActionFromEvent(event: EvenHubEvent): ActionName {
+  const item = event.listEvent?.currentSelectItemName?.trim();
+  if (isActionName(item)) return item;
+  const actions = currentMenu();
+  const index = event.listEvent?.currentSelectItemIndex;
+  if (typeof index === "number" && index >= 0 && index < actions.length) {
+    selectedActionIndex = index;
+  }
+  return actions[selectedActionIndex];
+}
+
+function isActionName(value: string | undefined): value is ActionName {
+  return value === "Talk" || value === "Send" || value === "Cancel";
+}
+
+async function runAction(action: ActionName): Promise<void> {
+  appendLog(`Action: ${action}`);
+  if (action === "Talk" || action === "Send") {
+    await toggleRecording();
+  } else if (action === "Cancel") {
+    if (recording) {
+      await cancelRecording();
+    } else if (thinking) {
+      await cancelThinking();
+    }
+  }
+}
+
+async function cancelRecording(): Promise<void> {
+  if (!recording) return;
+  await stopAudio();
+  audioChunks = [];
+  selectedActionIndex = 0;
+  await renderGlasses("Cancelled");
+}
+
+async function cancelThinking(): Promise<void> {
+  if (!thinking) return;
+  thinking = false;
+  ignoreNextReply = true;
+  pendingTranscript = null;
+  selectedActionIndex = 0;
+  await renderGlasses("Cancelled");
+}
+
+async function toggleRecording(): Promise<void> {
+  if (!bridge) {
+    appendLog("toggleRecording: no bridge");
+    return;
+  }
+  if (!recording) {
+    audioChunks = [];
+    recording = true;
+    selectedActionIndex = 0;
+    let opened: unknown;
+    try {
+      opened = await bridge.audioControl(true);
+    } catch (error) {
+      appendLog(`audioControl(true) threw: ${safeError(error)}`);
+      opened = false;
+    }
+    appendLog(`audioControl(true) -> ${opened}`);
+    if (!opened) {
+      recording = false;
+      await renderGlasses("Mic failed");
+      return;
+    }
+    await renderGlasses("Listening...");
+    return;
+  }
+  await stopAudio();
+  selectedActionIndex = 0;
+  if (audioChunks.length === 0) {
+    await renderGlasses("No audio captured");
+    return;
+  }
+  const pcmBase64 = bytesToBase64(concatBytes(audioChunks));
+  const sent = sendJson({ type: "audio", pcmBase64, sample_rate: 16000, channels: 1, input_mode: "voice" });
+  if (!sent) {
+    thinking = false;
+    await renderGlasses("Not connected.\nCheck server URL and token.");
+    return;
+  }
+  thinking = true;
+  await renderGlasses("Thinking...");
+}
+
+async function stopAudio(): Promise<void> {
+  if (!bridge || !recording) return;
+  recording = false;
+  await bridge.audioControl(false);
+}
+
+async function shutdown(): Promise<void> {
+  await stopAudio();
+  if (bridge) {
+    await bridge.shutDownPageContainer(1);
+  }
+  glassesReady = false;
+}
+
+function connect(): void {
+  void connectAsync();
+}
+
+async function connectAsync(): Promise<void> {
+  const server = await readSetting(STORAGE_SERVER);
+  if (!server) {
+    setStatus("Set server URL");
+    return;
+  }
+  const token = await readSetting(STORAGE_TOKEN);
+  const url = new URL("/ws", server);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  if (token) url.searchParams.set("token", token);
+  ws?.close();
+  ws = new WebSocket(url);
+  ws.addEventListener("open", () => setStatus("Connected"));
+  ws.addEventListener("close", () => setStatus("Disconnected"));
+  ws.addEventListener("message", (event) => {
+    void handleGatewayMessage(JSON.parse(event.data));
+  });
+}
+
+async function handleGatewayMessage(message: any): Promise<void> {
+  if (message.type === "reply") {
+    const text = message.display || message.reply || "";
+    appendLog(`Agent: ${text}`);
+    pendingTranscript = null;
+    thinking = false;
+    if (ignoreNextReply) {
+      ignoreNextReply = false;
+      return;
+    }
+    selectedActionIndex = 0;
+    await renderGlasses(text || "Done");
+  } else if (message.type === "notification") {
+    const notification = message.notification;
+    pendingTranscript = null;
+    thinking = false;
+    selectedActionIndex = 0;
+    await renderGlasses(`${notification.title}\n${notification.body}`);
+  } else if (message.type === "thinking" || message.type === "transcribing") {
+    if (!thinking) return;
+    await renderGlasses(pendingTranscript ? `You: ${pendingTranscript}\n\nThinking...` : "Thinking...");
+  } else if (message.type === "transcript") {
+    appendLog(`G2 voice: ${message.text}`);
+    if (!thinking) return;
+    if (typeof message.text === "string" && message.text.trim()) {
+      pendingTranscript = message.text.trim();
+      await renderGlasses(`You: ${pendingTranscript}\n\nThinking...`);
+    }
+  } else if (message.type === "error") {
+    pendingTranscript = null;
+    thinking = false;
+    if (ignoreNextReply) {
+      ignoreNextReply = false;
+      return;
+    }
+    selectedActionIndex = 0;
+    await renderGlasses(`Error\n${message.error}`);
+  }
+}
+
+function sendJson(payload: Record<string, unknown>): boolean {
+  if (!ws || ws.readyState !== WebSocket.OPEN) {
+    appendLog("Gateway is not connected.");
+    return false;
+  }
+  ws.send(JSON.stringify(payload));
+  return true;
+}
+
+async function readSetting(key: string): Promise<string> {
+  if (bridge) {
+    const value = await bridge.getLocalStorage(key);
+    if (value) return value;
+  }
+  return localStorage.getItem(key) || "";
+}
+
+async function writeSetting(key: string, value: string): Promise<void> {
+  if (bridge) {
+    await bridge.setLocalStorage(key, value);
+  }
+  localStorage.setItem(key, value);
+}
+
+function concatBytes(chunks: Uint8Array[]): Uint8Array {
+  const total = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+  const output = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    output.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return output;
+}
+
+function bytesToBase64(bytes: Uint8Array): string {
+  let binary = "";
+  const step = 0x8000;
+  for (let index = 0; index < bytes.length; index += step) {
+    binary += String.fromCharCode(...bytes.subarray(index, index + step));
+  }
+  return btoa(binary);
+}
+
+function setStatus(text: string): void {
+  statusEl.textContent = text;
+}
+
+function appendLog(text: string): void {
+  logEl.textContent = `${logEl.textContent}\n${text}`.trim();
+}

package/templates/even-g2-agent/src/style.css

@@ -0,0 +1,70 @@
+:root {
+  color-scheme: dark;
+  font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+  background: #101412;
+  color: #eef6ef;
+}
+
+body {
+  margin: 0;
+}
+
+main {
+  width: min(720px, calc(100vw - 32px));
+  margin: 0 auto;
+  padding: 28px 0;
+}
+
+h1 {
+  margin: 0 0 18px;
+  font-size: 24px;
+  line-height: 1.2;
+}
+
+form {
+  display: grid;
+  gap: 10px;
+  margin: 12px 0;
+}
+
+label {
+  display: grid;
+  gap: 5px;
+  color: #b6c7bd;
+  font-size: 13px;
+}
+
+input,
+button {
+  min-height: 42px;
+  box-sizing: border-box;
+  border: 1px solid #405048;
+  border-radius: 6px;
+  padding: 9px 11px;
+  font: inherit;
+}
+
+input {
+  width: 100%;
+  background: #0e1310;
+  color: #eef6ef;
+}
+
+button {
+  background: #d7f7d8;
+  color: #102014;
+}
+
+#status {
+  color: #b6c7bd;
+}
+
+#log {
+  min-height: 180px;
+  padding: 12px;
+  border: 1px solid #38443d;
+  border-radius: 8px;
+  background: #161d19;
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+}

package/templates/even-g2-agent/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "skipLibCheck": true,
+    "types": ["vite/client"]
+  },
+  "include": ["src/**/*.ts"]
+}

package/templates/skill-python/main.py

@@ -5,19 +5,37 @@ The entry point is run(ctx, input). Runtime provides:
   ctx.log.info(msg) / warn / error  : writes to logs/runs/<run-id>.json and events.jsonl
   ctx.memory.get(key) / set(key, v) : persists under skill.yaml memory.namespace
   ctx.ai.run(step_id, payload)      : calls an ai_steps entry declared in skill.yaml
-  ctx.notify(args)                  : notifies Discord/Telegram/macOS/Mail/Slack/stderr (auto recommended)
+  ctx.notify(args)                  : notifies Discord/Telegram/macOS/Mail/Slack/stderr (auto recommended);
+                                      pass filePath/filePaths to attach local files on Discord/Telegram
+  ctx.history.append({time?, meta?, content, replace?}) : insert/upsert one row in this skill's SQLite log
+  ctx.history.list({from?, to?, limit?})       : read past rows as [{time, meta, content}] (date range filter)
+  ctx.history.read({from?, to?})               : read past rows as one concatenated string (handy for ai_steps)
   ctx.now()                         : returns the current time as an ISO8601 string
 
 input format:
   {
     "args":    arguments validated by skill.yaml input.schema,
     "trigger": {"type": "manual", "id": ..., "time": "ISO8601"},
-    "sources": {"workspace": ..., "notes_dir": ..., ...},
+    "sources": {"workspace": ..., "notes_dir": ..., "skill_output_dir": ..., ...},
     "memory":  current ctx.memory snapshot,
   }
 
 Return a SkillResult. outputs.<id> maps to outputs[id] in skill.yaml.
 Runtime saves outputs, so the skill should not write files directly.
+
+If you need to write a user-visible markdown file with a name the runtime's
+outputs block doesn't fit (free-form filename, rotating log, accumulating list),
+write it under input["sources"]["skill_output_dir"]:
+
+    out_dir = input["sources"]["skill_output_dir"]
+    with open(os.path.join(out_dir, "my-log.md"), "a") as f:
+        f.write("...\n")
+
+The runtime creates this dir before invoking the skill. Use a plain filename
+like "marketing-log.md" — DO NOT create date-based subdirectories like
+2026/05/2026-05-22.md. Files placed here surface in Obsidian as
+"06 Skills/<skill-id>/...". For internal state the user shouldn't see, use
+ctx.memory or ctx.history, not this dir.
 """
 
 from __future__ import annotations

package/templates/skill-python/skill.yaml

@@ -42,6 +42,15 @@ memory:
   read: true
   write: true
 
+# Enable history when the skill should accumulate a queryable log (food,
+# weight, training, reviews, etc.). Entries land in ~/.agent-sin/data/<skill-id>.db
+# (SQLite, hidden from the user) and the skill reads them back via
+# ctx.history.list({from, to, limit}). Pair it with an outputs entry below if
+# you also want a human-readable Markdown report under notes/.
+# history:
+#   read: true
+#   write: true
+
 # Optional: set "raw" only when you want to return the summary directly to users.
 # By default, the LLM receives the result and formats a natural-language reply.
 # See https://agent.shingoirie.com/skill-authoring for details.