import type { Foreigns } from "../urbit/foreigns.js";

import { asRecord, formatErrorMessage } from "./utils.js";

export interface InitData {

interface InitData {

channels: string[];

foreigns: Foreigns | null;

}

return chunks.toReversed().join(".");

}

export type TlonHistoryEntry = {

type TlonHistoryEntry = {

author: string;

content: string;

timestamp: number;

}

}

export async function fetchChannelHistory(

async function fetchChannelHistory(

api: { scry: (path: string) => Promise<unknown> },

channelNest: string,

count = 50,

stripBotMention,

} from "./utils.js";

export type MonitorTlonOpts = {

type MonitorTlonOpts = {

runtime?: RuntimeEnv;

abortSignal?: AbortSignal;

accountId?: string | null;

const MAX_IMAGES_PER_MESSAGE = 8;

const TLON_MEDIA_DOWNLOAD_IDLE_TIMEOUT_MS = 30_000;

export interface ExtractedImage {

interface ExtractedImage {

url: string;

alt?: string;

}

export interface DownloadedMedia {

interface DownloadedMedia {

localPath: string;

contentType: string;

originalUrl: string;

import { createDedupeCache } from "../../runtime-api.js";

export type ProcessedMessageTracker = {

type ProcessedMessageTracker = {

claim: (id?: string | null) => { kind: "claimed" } | { kind: "duplicate" };

commit: (id?: string | null) => void;

release: (id?: string | null) => void;

import { normalizeShip } from "../targets.js";

import type { TlonResolvedAccount } from "../types.js";

export type TlonMonitorSettingsState = {

type TlonMonitorSettingsState = {

effectiveDmAllowlist: string[];

effectiveShowModelSig: boolean;

effectiveAutoAcceptDmInvites: boolean;

import { UrbitAuthError } from "./errors.js";

import { urbitFetch } from "./fetch.js";

export type UrbitAuthenticateOptions = {

type UrbitAuthenticateOptions = {

ssrfPolicy?: SsrFPolicy;

lookupFn?: LookupFn;

fetchImpl?: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;

import { isBlockedHostnameOrIp } from "openclaw/plugin-sdk/ssrf-runtime";

export type UrbitBaseUrlValidation =

type UrbitBaseUrlValidation =

| { ok: true; baseUrl: string; hostname: string }

| { ok: false; error: string };

import { UrbitHttpError } from "./errors.js";

import { urbitFetch } from "./fetch.js";

export type UrbitChannelDeps = {

type UrbitChannelDeps = {

baseUrl: string;

cookie: string;

ship: string;

}

}

export async function createUrbitChannel(

async function createUrbitChannel(

deps: UrbitChannelDeps,

params: { body: unknown; auditContext: string },

): Promise<void> {

}

}

export async function wakeUrbitChannel(deps: UrbitChannelDeps): Promise<void> {

async function wakeUrbitChannel(deps: UrbitChannelDeps): Promise<void> {

const { response, release } = await putUrbitChannel(deps, {

body: [

{

import { normalizeUrbitHostname, validateUrbitBaseUrl } from "./base-url.js";

import { UrbitUrlError } from "./errors.js";

export type UrbitContext = {

type UrbitContext = {

baseUrl: string;

hostname: string;

ship: string;

};

export function resolveShipFromHostname(hostname: string): string {

function resolveShipFromHostname(hostname: string): string {

const trimmed = normalizeUrbitHostname(hostname);

if (!trimmed) {

return "";

return trimmed;

}

export function normalizeUrbitShip(ship: string | undefined, hostname: string): string {

function normalizeUrbitShip(ship: string | undefined, hostname: string): string {

const raw = ship?.replace(/^~/, "") ?? resolveShipFromHostname(hostname);

return raw.trim();

}