@ericsanchezok/meta-synergy 1.1.26 → 1.2.17

package/src/display.ts

@@ -0,0 +1,70 @@
+export type MetaSynergyHiddenReason = "managed" | "policy"
+
+interface IdentifierValueOptions {
+  missing?: string
+  unknown?: string
+  hiddenReason?: MetaSynergyHiddenReason | null
+  showStart?: number
+  showEnd?: number
+}
+
+interface IdentifierListOptions extends IdentifierValueOptions {
+  separator?: string
+}
+
+export namespace MetaSynergyDisplay {
+  export function identifier(value: string | null | undefined, options?: IdentifierValueOptions): string {
+    if (value === null || value === undefined || value.length === 0) {
+      return options?.missing ?? "none"
+    }
+
+    if (options?.hiddenReason) {
+      return maskIdentifier(value, options)
+    }
+
+    return value
+  }
+
+  export function maybeIdentifier(value: unknown, options?: IdentifierValueOptions): string {
+    if (typeof value !== "string") {
+      return value == null ? (options?.missing ?? "none") : (options?.unknown ?? "unknown")
+    }
+
+    return identifier(value, options)
+  }
+
+  export function identifierList(values: Array<string> | undefined, options?: IdentifierListOptions): string {
+    if (!values || values.length === 0) {
+      return options?.missing ?? "none"
+    }
+
+    const separator = options?.separator ?? ", "
+    return values.map((value) => identifier(value, options)).join(separator)
+  }
+
+  export function maskIdentifier(
+    value: string,
+    options?: { hiddenReason?: MetaSynergyHiddenReason | null; showStart?: number; showEnd?: number },
+  ): string {
+    const showStart = options?.showStart ?? defaultPrefixLength(value)
+    const showEnd = options?.showEnd ?? defaultSuffixLength(value)
+
+    if (value.length <= showStart + showEnd + 3) {
+      return `${value.slice(0, Math.max(1, Math.min(4, value.length)))}...`
+    }
+
+    return `${value.slice(0, showStart)}...${value.slice(-showEnd)}`
+  }
+
+  function defaultPrefixLength(value: string) {
+    if (value.startsWith("env_")) return 8
+    if (value.startsWith("ses_")) return 8
+    return 8
+  }
+
+  function defaultSuffixLength(value: string) {
+    if (value.startsWith("env_")) return 7
+    if (value.startsWith("ses_")) return 6
+    return 8
+  }
+}

package/src/exec/process-registry.ts

@@ -83,14 +83,21 @@ export class ProcessRegistry {
       return this.#backgroundResult(launched.record, envID, request.description, "Background")
     }
 
-    if (request.yieldMs && request.yieldMs > 0) {
+    if (request.yieldSeconds && request.yieldSeconds > 0) {
+      const yieldMs = request.yieldSeconds * 1000
       const autoBackground = await Promise.race([
         this.#waitForExit(launched.record.processId).then(() => false),
-        Platform.sleep(request.yieldMs).then(() => !launched.record.exited),
+        Platform.sleep(yieldMs).then(() => !launched.record.exited),
       ])
       if (autoBackground) {
         launched.record.backgrounded = true
-        return this.#backgroundResult(launched.record, envID, request.description, "Auto-Background", request.yieldMs)
+        return this.#backgroundResult(
+          launched.record,
+          envID,
+          request.description,
+          "Auto-Background",
+          request.yieldSeconds,
+        )
       }
     }
 
@@ -547,10 +554,12 @@ export class ProcessRegistry {
     envID: string,
     description: string,
     mode: "Background" | "Auto-Background",
-    yieldMs?: number,
+    yieldSeconds?: number,
   ): MetaProtocolBash.Result {
     const prefix =
-      mode === "Auto-Background" ? `Command auto-backgrounded after ${yieldMs}ms.` : "Command started in background."
+      mode === "Auto-Background"
+        ? `Command auto-backgrounded after ${yieldSeconds}s.`
+        : "Command started in background."
     return {
       title: `[${mode}] ${description}`,
       metadata: {

package/src/holos/auth.ts

@@ -0,0 +1,183 @@
+import os from "node:os"
+import path from "node:path"
+import { chmod, mkdir, readFile, unlink, writeFile } from "node:fs/promises"
+import { applyEdits, modify } from "jsonc-parser"
+import z from "zod"
+import { MetaSynergyStore, type MetaSynergyAuthState } from "../state/store"
+
+export type MetaSynergyHolosAuthSource = "shared" | "legacy-migrated"
+
+export const HOLOS_API_HOST = "api.holosai.io"
+export const HOLOS_PORTAL_HOST = "www.holosai.io"
+export const HOLOS_URL = `https://${HOLOS_API_HOST}`
+export const HOLOS_WS_URL = `wss://${HOLOS_API_HOST}`
+export const HOLOS_PORTAL_URL = `https://${HOLOS_PORTAL_HOST}`
+
+const JSONC_FORMATTING = {
+  insertSpaces: true,
+  tabSize: 2,
+  eol: "\n",
+} as const
+
+const SynergyHolosAuth = z.object({
+  type: z.literal("holos"),
+  agentId: z.string(),
+  agentSecret: z.string(),
+})
+
+const SynergyAuthRecord = z.record(z.string(), z.unknown())
+const SynergyConfigSetMetadata = z.object({ active: z.string().min(1).default("default") })
+
+export namespace MetaSynergyHolosAuth {
+  export function synergyRoot() {
+    return path.join(process.env.SYNERGY_TEST_HOME || os.homedir(), ".synergy")
+  }
+
+  export function sharedAuthPath() {
+    return path.join(synergyRoot(), "data", "auth", "api-key.json")
+  }
+
+  export function configMetadataPath() {
+    return path.join(synergyRoot(), "config", "config-set.json")
+  }
+
+  export async function globalConfigPath() {
+    try {
+      const raw = await readFile(configMetadataPath(), "utf8")
+      const metadata = SynergyConfigSetMetadata.parse(JSON.parse(raw))
+      return metadata.active === "default"
+        ? path.join(synergyRoot(), "config", "synergy.jsonc")
+        : path.join(synergyRoot(), "config", "config-sets", metadata.active, "synergy.jsonc")
+    } catch {
+      return path.join(synergyRoot(), "config", "synergy.jsonc")
+    }
+  }
+
+  export async function inspect(): Promise<
+    { auth: MetaSynergyAuthState; source: MetaSynergyHolosAuthSource } | { auth: undefined; source: null }
+  > {
+    const shared = await loadShared()
+    if (shared) {
+      return {
+        auth: shared,
+        source: "shared",
+      }
+    }
+
+    const legacy = await loadLegacy()
+    if (!legacy) {
+      return {
+        auth: undefined,
+        source: null,
+      }
+    }
+
+    await saveShared(legacy)
+    return {
+      auth: legacy,
+      source: "legacy-migrated",
+    }
+  }
+
+  export async function load(): Promise<MetaSynergyAuthState | undefined> {
+    return (await inspect()).auth
+  }
+
+  export async function save(auth: MetaSynergyAuthState): Promise<void> {
+    await saveShared(auth)
+    await MetaSynergyStore.saveLegacyAuth(auth)
+    await configureHolos()
+  }
+
+  export async function configureHolos(): Promise<void> {
+    const filePath = await globalConfigPath()
+    const source = await loadGlobalConfigSource(filePath)
+    const next = applyEdits(
+      source,
+      modify(
+        source,
+        ["holos"],
+        {
+          enabled: true,
+          apiUrl: HOLOS_URL,
+          wsUrl: HOLOS_WS_URL,
+          portalUrl: HOLOS_PORTAL_URL,
+        },
+        { formattingOptions: JSONC_FORMATTING },
+      ),
+    )
+
+    await mkdir(path.dirname(filePath), { recursive: true })
+    await writeFile(filePath, next.endsWith("\n") ? next : `${next}\n`)
+    await chmod(filePath, 0o600).catch(() => undefined)
+  }
+
+  export async function clear(): Promise<void> {
+    await removeShared()
+    await MetaSynergyStore.clearLegacyAuth()
+  }
+
+  async function loadShared(): Promise<MetaSynergyAuthState | undefined> {
+    try {
+      const parsed = SynergyAuthRecord.parse(JSON.parse(await readFile(sharedAuthPath(), "utf8")))
+      const holos = SynergyHolosAuth.safeParse(parsed.holos)
+      if (!holos.success) return undefined
+      return {
+        agentID: holos.data.agentId,
+        agentSecret: holos.data.agentSecret,
+      }
+    } catch {
+      return undefined
+    }
+  }
+
+  async function loadLegacy(): Promise<MetaSynergyAuthState | undefined> {
+    return await MetaSynergyStore.loadLegacyAuth()
+  }
+
+  async function saveShared(auth: MetaSynergyAuthState): Promise<void> {
+    const filePath = sharedAuthPath()
+    let data: Record<string, unknown> = {}
+    try {
+      data = SynergyAuthRecord.parse(JSON.parse(await readFile(filePath, "utf8")))
+    } catch {
+      data = {}
+    }
+
+    const next = {
+      ...data,
+      holos: {
+        type: "holos",
+        agentId: auth.agentID,
+        agentSecret: auth.agentSecret,
+      },
+    }
+
+    await mkdir(path.dirname(filePath), { recursive: true })
+    await writeFile(filePath, JSON.stringify(next, null, 2) + "\n")
+    await chmod(filePath, 0o600)
+  }
+
+  async function removeShared(): Promise<void> {
+    let data: Record<string, unknown>
+    try {
+      data = SynergyAuthRecord.parse(JSON.parse(await readFile(sharedAuthPath(), "utf8")))
+    } catch {
+      await unlink(sharedAuthPath()).catch(() => undefined)
+      return
+    }
+
+    delete data.holos
+    await mkdir(path.dirname(sharedAuthPath()), { recursive: true })
+    await writeFile(sharedAuthPath(), JSON.stringify(data, null, 2) + "\n")
+  }
+
+  async function loadGlobalConfigSource(filePath: string): Promise<string> {
+    try {
+      const source = await readFile(filePath, "utf8")
+      return source.trim().length > 0 ? source : "{}\n"
+    } catch {
+      return "{}\n"
+    }
+  }
+}

package/src/holos/login.ts

@@ -1,16 +1,18 @@
 import process from "node:process"
 import { createServer, type IncomingMessage } from "node:http"
 import { spawn } from "node:child_process"
-import { MetaSynergyStore } from "../state/store"
+import { createInterface } from "node:readline/promises"
+import { stdin as input, stdout as output } from "node:process"
+import { MetaSynergyStore, type MetaSynergyAuthState } from "../state/store"
+import { HOLOS_PORTAL_URL, HOLOS_URL, MetaSynergyHolosAuth } from "./auth"
 import { MetaSynergyHolosProtocol } from "./protocol"
 
-const HOLOS_HOST = "www.holosai.io"
-const HOLOS_URL = `https://${HOLOS_HOST}`
+const LOGIN_TIMEOUT_MS = 5 * 60_000
 
 export namespace MetaSynergyHolosLogin {
   export function createBindURL(input: { callbackURL: string; state: string }) {
     return (
-      `${HOLOS_URL}/api/v1/holos/agent_tunnel/bind/start` +
+      `${HOLOS_PORTAL_URL}/api/v1/holos/agent_tunnel/bind/start` +
       `?local_callback=${encodeURIComponent(input.callbackURL)}` +
       `&state=${encodeURIComponent(input.state)}`
     )
@@ -27,6 +29,57 @@ export namespace MetaSynergyHolosLogin {
     return { valid: true }
   }
 
+  export async function loginWithExistingCredentials(auth: MetaSynergyAuthState): Promise<{ agentID: string }> {
+    const verification = await verifySecret(auth.agentSecret)
+    if (!verification.valid) {
+      throw new Error(`Credential validation failed: ${verification.reason}`)
+    }
+
+    await MetaSynergyHolosAuth.save(auth)
+    return { agentID: auth.agentID }
+  }
+
+  export async function promptForExistingCredentials(): Promise<MetaSynergyAuthState | null> {
+    const agentID = await promptText("Agent ID: ")
+    if (!agentID) {
+      return null
+    }
+
+    const agentSecret = await promptSecret("Agent Secret: ")
+    if (!agentSecret) {
+      return null
+    }
+
+    return {
+      agentID,
+      agentSecret,
+    }
+  }
+
+  export async function promptLoginMode(): Promise<"browser" | "existing" | null> {
+    if (!input.isTTY || !output.isTTY) {
+      return null
+    }
+
+    while (true) {
+      output.write(
+        ["Choose login mode:", "  1) Browser login", "  2) Import existing agent credentials", "Select [1]: "].join(
+          "\n",
+        ),
+      )
+
+      const answer = await readLine()
+      const normalized = answer.trim().toLowerCase()
+      if (normalized === "" || normalized === "1" || normalized === "browser" || normalized === "b") {
+        return "browser"
+      }
+      if (normalized === "2" || normalized === "existing" || normalized === "import" || normalized === "i") {
+        return "existing"
+      }
+      output.write("Invalid selection. Enter 1 or 2.\n\n")
+    }
+  }
+
   export async function login(): Promise<{ agentID: string }> {
     await MetaSynergyStore.ensureRoot()
     const state = crypto.randomUUID()
@@ -75,7 +128,7 @@ export namespace MetaSynergyHolosLogin {
       const timer = setTimeout(() => {
         server.close()
         reject(new Error("Login timed out."))
-      }, 5 * 60_000)
+      }, LOGIN_TIMEOUT_MS)
       timer.unref?.()
     })
 
@@ -113,12 +166,10 @@ export namespace MetaSynergyHolosLogin {
       throw new Error("Holos exchange did not return an agent secret.")
     }
 
-    await MetaSynergyStore.saveAuth({
+    return await loginWithExistingCredentials({
       agentID: exchangeBody.data.agent_id,
       agentSecret,
     })
-
-    return { agentID: exchangeBody.data.agent_id }
   }
 }
 
@@ -143,6 +194,95 @@ async function launchBrowser(url: string): Promise<void> {
   child.unref()
 }
 
+async function promptText(prompt: string): Promise<string | null> {
+  if (!input.isTTY || !output.isTTY) {
+    return null
+  }
+
+  output.write(prompt)
+  const answer = await readLine()
+  const value = answer.trim()
+  return value ? value : null
+}
+
+async function promptSecret(prompt: string): Promise<string | null> {
+  if (!input.isTTY || !output.isTTY) {
+    return null
+  }
+
+  output.write(prompt)
+  const secret = await readSecretLine()
+  output.write("\n")
+  const value = secret.trim()
+  return value ? value : null
+}
+
+async function readLine(): Promise<string> {
+  const rl = createInterface({ input, output, terminal: false })
+  try {
+    return await rl.question("")
+  } finally {
+    rl.close()
+  }
+}
+
+async function readSecretLine(): Promise<string> {
+  if (!input.isTTY) {
+    return await readLine()
+  }
+
+  const previousRawMode = typeof input.setRawMode === "function" ? input.isRaw : undefined
+  const chunks: string[] = []
+
+  return await new Promise<string>((resolve, reject) => {
+    const cleanup = () => {
+      input.off("data", onData)
+      input.off("error", onError)
+      if (typeof input.setRawMode === "function") {
+        input.setRawMode(Boolean(previousRawMode))
+      }
+      input.pause()
+    }
+
+    const finish = () => {
+      cleanup()
+      resolve(chunks.join(""))
+    }
+
+    const onError = (error: Error) => {
+      cleanup()
+      reject(error)
+    }
+
+    const onData = (chunk: Buffer | string) => {
+      const text = typeof chunk === "string" ? chunk : chunk.toString("utf8")
+      for (const char of text) {
+        if (char === "\r" || char === "\n") {
+          finish()
+          return
+        }
+        if (char === "\u0003") {
+          cleanup()
+          reject(new Error("Cancelled"))
+          return
+        }
+        if (char === "\u007f" || char === "\b") {
+          chunks.pop()
+          continue
+        }
+        chunks.push(char)
+      }
+    }
+
+    if (typeof input.setRawMode === "function") {
+      input.setRawMode(true)
+    }
+    input.resume()
+    input.on("data", onData)
+    input.on("error", onError)
+  })
+}
+
 function htmlPage(input: { title: string; status: "success" | "failed"; heading: string; message: string }): string {
   const accent = input.status === "success" ? "#86efac" : "#fca5a5"
   const badge = input.status === "success" ? "Connected" : "Error"

package/src/inbound/handler.ts

@@ -1,5 +1,5 @@
 import { MetaProtocolEnvelope, MetaProtocolError, MetaProtocolSession } from "@ericsanchezok/meta-protocol"
-import type { HolosCaller } from "../types"
+import { HolosCallerSchema, type HolosCaller } from "../types"
 import { RPCHandler } from "../rpc/handler"
 import { RPCRequestSchema, type RPCResult } from "../rpc/schema"
 import { SessionManager } from "../session/manager"
@@ -14,12 +14,13 @@ export class MetaSynergyInboundHandler {
     readonly decideOpen: (input: { caller: HolosCaller; label?: string }) => Promise<SessionOpenDecision>,
   ) {}
 
-  async handle(input: { caller: HolosCaller; body: unknown }): Promise<RPCResult> {
+  async handle(input: { caller: HolosCaller | unknown; body: unknown }): Promise<RPCResult> {
     try {
+      const caller = HolosCallerSchema.parse(input.caller)
       const request = RPCRequestSchema.parse(input.body)
       MetaSynergyLog.info("inbound.request.accepted", {
-        callerAgentID: input.caller.agentID,
-        callerOwnerUserID: input.caller.ownerUserID,
+        callerAgentID: caller.agentID,
+        callerOwnerUserID: caller.ownerUserID,
         tool: request.tool,
         action: request.action,
         requestID: request.requestID,
@@ -29,13 +30,13 @@ export class MetaSynergyInboundHandler {
       })
 
       if (request.tool === "session") {
-        return this.#handleSession(input.caller, request)
+        return this.#handleSession(caller, request)
       }
 
-      this.sessions.validateCaller(input.caller, request.sessionID)
+      this.sessions.validateCaller(caller, request.sessionID)
       const result = await this.rpc.handle(request)
       MetaSynergyLog.info("inbound.request.completed", {
-        callerAgentID: input.caller.agentID,
+        callerAgentID: caller.agentID,
         tool: request.tool,
         action: request.action,
         requestID: request.requestID,
@@ -44,8 +45,13 @@ export class MetaSynergyInboundHandler {
       return result
     } catch (error) {
       if (isEnvelopeError(error)) {
+        const callerAgentID =
+          typeof input.caller === "object" && input.caller !== null && "agentID" in input.caller
+            ? String((input.caller as { agentID?: unknown }).agentID ?? "unknown")
+            : "unknown"
         MetaSynergyLog.warn("inbound.request.failed.envelope", {
-          callerAgentID: input.caller.agentID,
+          callerAgentID,
+
           code: error.code,
           message: error.message,
           details: error.details,
@@ -62,8 +68,13 @@ export class MetaSynergyInboundHandler {
         )
       }
 
+      const callerAgentID =
+        typeof input.caller === "object" && input.caller !== null && "agentID" in input.caller
+          ? String((input.caller as { agentID?: unknown }).agentID ?? "unknown")
+          : "unknown"
       MetaSynergyLog.error("inbound.request.failed.unexpected", {
-        callerAgentID: input.caller.agentID,
+        callerAgentID,
+
         error: error instanceof Error ? error.message : String(error),
       })
       return errorResult(undefined, "host_internal_error", error instanceof Error ? error.message : String(error))

package/src/index.ts

@@ -3,6 +3,7 @@ export * from "./log"
 export * from "./host"
 export * from "./platform"
 export * from "./runtime"
+export * from "./owner-registry"
 export * from "./client/holos-client"
 export * from "./session/manager"
 export * from "./inbound/handler"

package/src/migration/index.ts

@@ -0,0 +1,22 @@
+import { MetaSynergyStore } from "../state/store"
+import { MetaSynergyStateMigrations } from "../state/migration"
+import type { MetaSynergyMigration } from "./types"
+export type { MetaSynergyMigration } from "./types"
+
+export namespace MetaSynergyMigrationRunner {
+  export async function run(): Promise<void> {
+    const applied = await MetaSynergyStore.loadMigrationLog()
+    const migrations = collect().sort((left, right) => left.id.localeCompare(right.id))
+
+    for (const migration of migrations) {
+      if (applied[migration.id]) continue
+      await migration.run()
+      applied[migration.id] = Date.now()
+      await MetaSynergyStore.saveMigrationLog(applied)
+    }
+  }
+}
+
+function collect(): MetaSynergyMigration[] {
+  return [...MetaSynergyStateMigrations.migrations]
+}

package/src/migration/types.ts

@@ -0,0 +1,5 @@
+export interface MetaSynergyMigration {
+  id: string
+  description: string
+  run(): Promise<void>
+}