@anhlp/alp 0.0.1-beta.4 → 0.0.1-beta.7

package/packages/client/dist/websocket.d.ts

@@ -1,51 +0,0 @@
-/** A URL fit for an error message: no credentials, query or fragment, which may carry a token. @param {string} url */
-export function redactUrl(url: string): string;
-/**
- * Wraps an open WebSocket in an ALP transport. The transport owns the socket from then on.
- * @param {WebSocketLike} socket
- * @param {WebSocketTransportOptions} [options]
- * @returns {AlpTransport}
- */
-export function createWebSocketTransport(socket: WebSocketLike, { maxFrame, maxBufferedBytes }?: WebSocketTransportOptions): AlpTransport;
-/**
- * Opens a WebSocket to `url` and resolves with its transport once it is open. The socket comes
- * from `createSocket`, else `new WebSocket(url, protocols)` with the injected or global WebSocket.
- * Errors name the URL without its credentials, query or fragment.
- * @param {string} url
- * @param {ConnectWebSocketOptions} [options]
- * @returns {Promise<AlpTransport>}
- */
-export function connectWebSocket(url: string, { WebSocket: Implementation, protocols, createSocket, signal, timeoutMs, ...options }?: ConnectWebSocketOptions): Promise<AlpTransport>;
-/** Close codes this transport sends when the peer breaks the protocol. */
-export const CLOSE_CODE: Readonly<{
-    unsupportedData: 4003;
-    tooLarge: 4009;
-}>;
-export type AlpTransport = import("./rpc/client.js").AlpTransport;
-export type TransportClose = import("./rpc/client.js").TransportClose;
-export type AbortSignalLike = import("./rpc/client.js").AbortSignalLike;
-export type WebSocketLike = {
-    readonly readyState: number;
-    readonly bufferedAmount?: number;
-    binaryType?: string;
-    send(data: string): void;
-    close(code?: number, reason?: string): void;
-    addEventListener?(type: string, listener: (event: any) => void): void;
-    removeEventListener?(type: string, listener: (event: any) => void): void;
-    onopen?: ((event: any) => void) | null;
-    onmessage?: ((event: any) => void) | null;
-    onerror?: ((event: any) => void) | null;
-    onclose?: ((event: any) => void) | null;
-};
-export type WebSocketConstructor = new (url: string, protocols?: string | string[]) => WebSocketLike;
-export type WebSocketTransportOptions = {
-    maxFrame?: number;
-    maxBufferedBytes?: number;
-};
-export type ConnectWebSocketOptions = WebSocketTransportOptions & {
-    WebSocket?: WebSocketConstructor;
-    protocols?: string | string[];
-    createSocket?: (url: string, protocols?: string | string[]) => WebSocketLike;
-    signal?: AbortSignalLike;
-    timeoutMs?: number;
-};

package/packages/client/dist/websocket.js

@@ -1,190 +0,0 @@
-// packages/client/src/websocket.js
-import { MAX_FRAME } from "@anhlp/alp-protocol";
-import { AlpClientError } from "./rpc/errors.js";
-import { utf8Length } from "./rpc/framing.js";
-import { timerDelay } from "./rpc/timers.js";
-var CONNECTING = 0;
-var OPEN = 1;
-var CLOSE_CODE = Object.freeze({ unsupportedData: 4003, tooLarge: 4009 });
-var CLOSE_AFTER_ERROR_MS = 250;
-var MAX_CLOSE_REASON = 123;
-function redactUrl(url) {
-  const match = /^([a-z][a-z0-9+.-]*:\/\/)(?:[^/?#\\]*@)?([^/?#\\@]*)([^?#]*)/i.exec(String(url));
-  return match ? `${match[1]}${match[2]}${match[3]}` : "<websocket>";
-}
-function scrubbed(error, url) {
-  const text = error instanceof Error ? error.message : String(error ?? "");
-  const message = (text.split(String(url)).join(redactUrl(url)) || "WebSocket error").replace(/[a-z][a-z0-9+.-]*:\/\/[^\s'"<>]+/gi, (found) => redactUrl(found));
-  const clean = new Error(message);
-  if (error instanceof Error && error.name) clean.name = error.name;
-  return clean;
-}
-function closeReason(reason) {
-  let cut = reason;
-  while (utf8Length(cut) > MAX_CLOSE_REASON) cut = cut.slice(0, -1);
-  return cut;
-}
-function release(socket, code, reason) {
-  if (socket.readyState !== CONNECTING && socket.readyState !== OPEN) return;
-  try {
-    if (code === void 0) socket.close();
-    else socket.close(code, closeReason(reason ?? ""));
-    return;
-  } catch {
-  }
-  try {
-    socket.close();
-  } catch {
-  }
-}
-function absorbErrors(socket) {
-  if (typeof socket.addEventListener === "function") socket.addEventListener("error", () => {
-  });
-}
-function listen(socket, type, listener) {
-  if (typeof socket.addEventListener === "function") {
-    socket.addEventListener(type, listener);
-    return () => socket.removeEventListener?.(type, listener);
-  }
-  const key = (
-    /** @type {'onopen' | 'onmessage' | 'onerror' | 'onclose'} */
-    `on${type}`
-  );
-  const previous = socket[key];
-  socket[key] = (event) => {
-    previous?.(event);
-    listener(event);
-  };
-  return () => {
-    socket[key] = previous ?? null;
-  };
-}
-var errorOf = (event) => {
-  const message = event?.error instanceof Error && event.error.message || typeof event?.message === "string" && event.message || "WebSocket error";
-  return event?.error instanceof Error && event.error.message ? event.error : new Error(message);
-};
-function createWebSocketTransport(socket, { maxFrame = MAX_FRAME, maxBufferedBytes = 4 * MAX_FRAME } = {}) {
-  if (socket.readyState !== OPEN) throw new AlpClientError("WebSocket is not open", { reason: "disconnected" });
-  absorbErrors(socket);
-  try {
-    socket.binaryType = "arraybuffer";
-  } catch {
-  }
-  const messages = /* @__PURE__ */ new Set();
-  const closes = /* @__PURE__ */ new Set();
-  let ended;
-  const detach = [];
-  let failed;
-  let failTimer;
-  const end = (close) => {
-    if (ended) return;
-    ended = close;
-    if (failTimer !== void 0) clearTimeout(failTimer);
-    for (const remove of detach.splice(0)) remove();
-    messages.clear();
-    const listeners = [...closes];
-    closes.clear();
-    for (const listener of listeners) listener(close);
-  };
-  const violate = (message, code) => {
-    const error = new AlpClientError(message, { reason: "protocol" });
-    release(socket, code, message);
-    end({ error });
-  };
-  detach.push(listen(socket, "message", (event) => {
-    if (ended) return;
-    const data = event?.data;
-    if (typeof data !== "string") return violate("Binary WebSocket messages are not ALP frames", CLOSE_CODE.unsupportedData);
-    if (utf8Length(data) > maxFrame) return violate(`ALP frame exceeds ${maxFrame} bytes`, CLOSE_CODE.tooLarge);
-    for (const line of data.includes("\n") ? data.split("\n") : [data]) {
-      if (ended) return;
-      if (line.trim()) for (const listener of [...messages]) listener(line);
-    }
-  }));
-  detach.push(listen(socket, "close", (event) => end({ error: failed, code: typeof event?.code === "number" ? event.code : void 0, reason: typeof event?.reason === "string" && event.reason ? event.reason : void 0 })));
-  detach.push(listen(socket, "error", (event) => {
-    if (failed) return;
-    failed = errorOf(event);
-    failTimer = setTimeout(() => end({ error: failed }), CLOSE_AFTER_ERROR_MS);
-    release(socket);
-  }));
-  return {
-    get state() {
-      return ended || socket.readyState !== OPEN ? "closed" : "open";
-    },
-    send(frame) {
-      if (ended || socket.readyState !== OPEN) throw new AlpClientError("WebSocket is not open", { reason: "send_failed" });
-      if ((socket.bufferedAmount ?? 0) + utf8Length(frame) > maxBufferedBytes) throw new AlpClientError(`WebSocket send buffer is over ${maxBufferedBytes} bytes`, { reason: "send_failed" });
-      socket.send(frame);
-    },
-    onMessage(listener) {
-      if (ended) return () => false;
-      messages.add(listener);
-      return () => messages.delete(listener);
-    },
-    onClose(listener) {
-      if (ended) return () => false;
-      closes.add(listener);
-      return () => closes.delete(listener);
-    },
-    close() {
-      release(socket, 1e3, "client closed");
-      end({ code: 1e3, reason: "client closed" });
-    }
-  };
-}
-function connectWebSocket(url, { WebSocket: Implementation, protocols, createSocket, signal, timeoutMs = 15e3, ...options } = {}) {
-  const where = redactUrl(url);
-  let delay;
-  try {
-    delay = timerDelay(timeoutMs);
-  } catch (error) {
-    return Promise.reject(error);
-  }
-  if (signal?.aborted) return Promise.reject(new AlpClientError(`Connecting to ${where} was aborted`, { reason: "aborted", cause: signal.reason }));
-  const Constructor = Implementation ?? /** @type {any} */
-  globalThis.WebSocket;
-  if (!createSocket && typeof Constructor !== "function") return Promise.reject(new TypeError("No WebSocket implementation: pass options.WebSocket or options.createSocket"));
-  let socket;
-  try {
-    socket = createSocket ? createSocket(url, protocols) : protocols === void 0 ? new Constructor(url) : new Constructor(url, protocols);
-  } catch (error) {
-    return Promise.reject(new AlpClientError(`Could not connect to ${where}`, { reason: "disconnected", cause: scrubbed(error, url) }));
-  }
-  absorbErrors(socket);
-  return new Promise((resolve, reject) => {
-    const detach = [];
-    let timer;
-    const settle = () => {
-      for (const remove of detach.splice(0)) remove();
-      if (timer !== void 0) clearTimeout(timer);
-      signal?.removeEventListener("abort", onAbort);
-    };
-    const fail = (error) => {
-      settle();
-      release(socket);
-      reject(error);
-    };
-    const onAbort = () => fail(new AlpClientError(`Connecting to ${where} was aborted`, { reason: "aborted", cause: signal?.reason }));
-    const open = () => {
-      settle();
-      try {
-        resolve(createWebSocketTransport(socket, options));
-      } catch (error) {
-        reject(error);
-      }
-    };
-    if (socket.readyState === OPEN) return open();
-    detach.push(listen(socket, "open", open));
-    detach.push(listen(socket, "error", (event) => fail(new AlpClientError(`Could not connect to ${where}`, { reason: "disconnected", cause: scrubbed(errorOf(event), url) }))));
-    detach.push(listen(socket, "close", (event) => fail(new AlpClientError(`Could not connect to ${where}`, { reason: "disconnected", data: { code: event?.code, reason: event?.reason || void 0 } }))));
-    signal?.addEventListener("abort", onAbort, { once: true });
-    if (delay !== void 0) timer = setTimeout(() => fail(new AlpClientError(`Connecting to ${where} timed out after ${timeoutMs} ms`, { reason: "timeout" })), delay);
-  });
-}
-export {
-  CLOSE_CODE,
-  connectWebSocket,
-  createWebSocketTransport,
-  redactUrl
-};

package/packages/core/README.md

@@ -1,7 +0,0 @@
-# @anhlp/alp-core
-
-Filesystem configuration, agent resolution, teams, tasks, permissions and shipped templates.
-
-Build: `npm run build --workspace=@anhlp/alp-core`. Test: `npm run test --workspace=@anhlp/alp-core`.
-
-Public imports use the package root and its explicitly exported subpaths. See [architecture, provider extension, compatibility and release instructions](../../docs/modular-monorepo.md).

package/packages/core/dist/adapter.d.ts

@@ -1,20 +0,0 @@
-import type { ResolvedAgent } from './types.js';
-export type CapabilitySupport = 'native' | 'emulated' | 'unsupported';
-export interface AdapterCapabilities {
-  instructions: CapabilitySupport;
-  skills: CapabilitySupport;
-  hooks: CapabilitySupport;
-  mcp: CapabilitySupport;
-}
-export interface CompiledAgent<T = unknown> {
-  adapterId: string;
-  agentName: string;
-  projectRoot: string;
-  material: T;
-}
-export interface AlpRuntimeAdapter<T = unknown> {
-  id: string;
-  capabilities(): AdapterCapabilities;
-  compile(agent: ResolvedAgent): Promise<CompiledAgent<T>>;
-}
-export function compileAgent<T>(adapter: AlpRuntimeAdapter<T>, agent: ResolvedAgent): Promise<CompiledAgent<T>>;

package/packages/core/dist/adapter.js

@@ -1,30 +0,0 @@
-// packages/core/src/adapter.js
-import { AlpError } from "./errors.js";
-import { validateResolvedAgent } from "./validation.js";
-async function compileAgent(adapter, agent) {
-  if (!adapter || typeof adapter.id !== "string" || !adapter.id.trim() || typeof adapter.capabilities !== "function" || typeof adapter.compile !== "function") {
-    throw new AlpError("INVALID_ADAPTER", "Adapter requires id, capabilities(), and compile()");
-  }
-  validateResolvedAgent(agent);
-  const capabilities = adapter.capabilities();
-  for (const key of ["instructions", "skills", "hooks", "mcp"]) {
-    if (!["native", "emulated", "unsupported"].includes(capabilities?.[key])) throw new AlpError("INVALID_CAPABILITIES", `${adapter.id}: invalid ${key} capability`);
-  }
-  const required = {
-    instructions: Boolean(agent.instructions.project || agent.instructions.agent),
-    skills: agent.skills.length > 0,
-    hooks: agent.hooks.length > 0,
-    mcp: Object.keys(agent.mcp.mcpServers).length > 0
-  };
-  for (const [key, present] of Object.entries(required)) {
-    if (present && capabilities[key] === "unsupported") throw new AlpError("UNSUPPORTED_CAPABILITY", `${adapter.id} does not support ${key} required by '${agent.name}'`);
-  }
-  const compiled = await adapter.compile(structuredClone(agent));
-  if (!compiled || compiled.adapterId !== adapter.id || compiled.agentName !== agent.name || compiled.projectRoot !== agent.projectRoot || !Object.hasOwn(compiled, "material")) {
-    throw new AlpError("INVALID_COMPILED_AGENT", `${adapter.id}: invalid compiled agent envelope`);
-  }
-  return compiled;
-}
-export {
-  compileAgent
-};

package/packages/core/dist/atomic.d.ts

@@ -1,2 +0,0 @@
-export function moveFile(from: string, to: string): Promise<void>;
-export function writeAtomic(file: string, body: string | Uint8Array, mode?: number): Promise<void>;

package/packages/core/dist/atomic.js

@@ -1,28 +0,0 @@
-// packages/core/src/atomic.js
-import { randomBytes } from "node:crypto";
-import { rename, rm, writeFile } from "node:fs/promises";
-async function moveFile(from, to) {
-  for (let attempt = 0; ; attempt++) {
-    try {
-      return await rename(from, to);
-    } catch (error) {
-      if (process.platform !== "win32" || attempt >= 20 || !["EPERM", "EACCES", "EBUSY"].includes(error?.code)) throw error;
-      await new Promise((resolve) => setTimeout(resolve, 10 + attempt * 10));
-    }
-  }
-}
-async function writeAtomic(file, body, mode = 384) {
-  const temporary = `${file}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
-  try {
-    await writeFile(temporary, body, { mode });
-    await moveFile(temporary, file);
-  } catch (error) {
-    await rm(temporary, { force: true }).catch(() => {
-    });
-    throw error;
-  }
-}
-export {
-  moveFile,
-  writeAtomic
-};

package/packages/core/dist/backup.d.ts

@@ -1,27 +0,0 @@
-export const BACKUP_FORMAT: number;
-export const BACKUP_EXTENSION: string;
-export const STATE_UNITS: string[];
-export const CLEARED_UNITS: string[];
-export const HOME_UNITS: string[];
-export const PROJECT_UNITS: string[];
-export function backupsDir(home: string): string;
-export function knownProjects(home: string): Promise<string[]>;
-export type BackupSummary = { file: string; files: number; bytes: number; projects: string[]; stateSchema: number | null; sessions: number; tasks: number };
-export function createBackup(options: { home: string; out: string; units?: string[]; projects?: string[]; by?: string; kind?: string }): Promise<BackupSummary>;
-export function automaticBackup(home: string, kind: string, options?: { units?: string[]; projects?: string[]; by?: string }): Promise<string>;
-export type BackupContents = { file: string; kind: string; by?: string; createdAt: string; home: string; stateSchema: number | null; units: string[]; projects: string[]; sessions: number; tasks: number; files: number; bytes: number; external: number };
-export function verifyBackup(file: string): Promise<BackupContents>;
-export function recoverInterruptedRestore(home: string): Promise<{ outcome: 'rolled back' | 'completed'; file?: string; safety?: string } | undefined>;
-export type RestoreResult = {
-  file: string;
-  safety?: string;
-  stateSchema: number | null;
-  interrupted?: { outcome: 'rolled back' | 'completed'; file?: string; safety?: string };
-  units: Array<{ area: string; unit: string; present: boolean }>;
-  projects: string[];
-  skipped: Array<{ root: string; reason: string }>;
-  warnings: string[];
-};
-export function restoreBackup(options: { home: string; file: string; projects?: boolean; safety?: boolean; clearLive?: boolean; replaceNewer?: boolean; by?: string; beforeSwap?: (index: number, total: number) => Promise<void> | void }): Promise<RestoreResult>;
-export function readRestoredMarker(home: string): Promise<{ at?: string; from?: string; by?: string } | undefined>;
-export function clearRestoredMarker(home: string): Promise<void>;