@ai-ecoverse/slicc-kernel 1.102.5 → 1.103.0

package/dist/types/realm/sync-sab-wire.d.ts

@@ -0,0 +1,64 @@
+import type { WasmSyscall } from '../kernel/process.js';
+import type { SyncFsRequest, SyncFsResult } from './sync-fs-wire.js';
+export declare const SAB_HEADER_I32 = 18;
+export declare const SAB_CLOCK_OFFSET: number;
+export declare const SAB_CLOCK_I64 = 3;
+export declare const SAB_HEADER_BYTES: number;
+export declare const SAB_I_STATE = 0;
+export declare const SAB_I_SEQ = 1;
+export declare const SAB_I_STATUS = 2;
+export declare const SAB_I_TOTAL = 3;
+export declare const SAB_I_CHUNK = 4;
+export declare const SAB_I_OFFSET = 5;
+export declare const SAB_I_REQ = 6;
+export declare const SAB_I_PUB = 7;
+export declare const SAB_I_SIGNALS = 8;
+export declare const SAB_I_TIMERS = 9;
+export declare const SAB_I_MEMORY = 10;
+export declare const SAB_I_TOTAL_HI = 11;
+export declare const SAB_I_OFFSET_HI = 12;
+export declare const SAB_I_KILLED = 13;
+export declare const SAB_I_ASYNC = 14;
+export declare const SAB_I_STOP = 15;
+export declare const SAB_I_BLOCKED = 16;
+export declare const SAB_I_BLOCKED_HI = 17;
+export type BlockedMask = readonly [number, number];
+export declare function loadBlocked(header: Int32Array): BlockedMask;
+export declare function storeBlocked(header: Int32Array, [low, high]: BlockedMask): void;
+export declare const anyBlocked: (mask: BlockedMask | undefined) => boolean;
+export declare function storeU53(header: Int32Array, lo: number, hi: number, value: number): void;
+export declare function loadU53(header: Int32Array, lo: number, hi: number): number;
+export declare function publishMemory(sab: SharedArrayBuffer, bytes: number): void;
+export declare const SAB_STATE_IDLE = 0;
+export declare const SAB_STATE_PENDING = 1;
+export declare const SAB_STATE_READY = 2;
+export declare const SAB_STATUS_BYTES = 1;
+export declare const SAB_STATUS_JSON = 2;
+export declare const SAB_STATUS_VOID = 3;
+export declare const SAB_STATUS_ERRNO = 4;
+export declare const SAB_DEFAULT_WINDOW_BYTES: number;
+export declare const SAB_MIN_BYTES: number;
+export declare const SYNC_SAB_REQ_MSG = "sync-sab-req";
+export declare const SYNC_SAB_NEXT_MSG = "sync-sab-next";
+export type SyncSabRequestBody = Omit<SyncFsRequest, 'token'> | WasmSyscall;
+export interface SyncSabReqMsg {
+    type: typeof SYNC_SAB_REQ_MSG;
+    id: number;
+    req: SyncSabRequestBody;
+}
+export interface SyncSabNextMsg {
+    type: typeof SYNC_SAB_NEXT_MSG;
+    id: number;
+    offset: number;
+}
+export interface SabEncodedResult {
+    status: number;
+    payload: Uint8Array;
+}
+export declare function encodeSabResult(result: SyncFsResult): SabEncodedResult;
+export declare function decodeSabResult(status: number, payload: Uint8Array): SyncFsResult;
+export interface SabViews {
+    header: Int32Array;
+    window: Uint8Array;
+}
+export declare function sabViews(sab: SharedArrayBuffer): SabViews;

package/dist/types/sealed-relay.d.ts

@@ -0,0 +1,26 @@
+import type { SealedHook, SealedRequest } from './kernel/sealed.js';
+export interface SealedPort {
+    postMessage(message: unknown): void;
+}
+export interface SealedAsk {
+    id: number;
+    req: SealedRequest;
+}
+export interface SealedReply {
+    id: number;
+    reply?: object;
+    error?: string;
+}
+export interface SealedAbort {
+    id: number;
+    reason: unknown;
+}
+export declare function sealedAsker(port: SealedPort): {
+    hook: SealedHook;
+    answer(reply: SealedReply): void;
+};
+export interface SealedAnswerer {
+    handle(data: unknown): boolean;
+    close(): void;
+}
+export declare function sealedAnswerer(port: SealedPort, hook: SealedHook | undefined): SealedAnswerer;

package/dist/types/serve.d.ts

@@ -0,0 +1,190 @@
+import { type LockManagerLike } from './client/protocol.js';
+import { type MetaStore } from './fs/meta.js';
+import { type ProtectInit } from './fs/protect.js';
+import { type UsersMode } from './fs/types.js';
+import type { WasmWorkerLike } from './kernel/host.js';
+import type { RouteTable } from './kernel/net/routes.js';
+import type { RealmTransportTraits } from './kernel/net/transport.js';
+import { type UplinkTraits } from './kernel/net/uplink.js';
+import { type RunOptions, type TerminalOptions } from './launcher.js';
+import type { MediumHandle } from './mount/fsa.js';
+import type { HostfsGrant, HostfsPortGrant } from './mount/hostfs.js';
+import type { MediaStore } from './mount/media.js';
+import type { MountSpec } from './mount/mount-fs.js';
+import type { AddUser, RemoveUser } from './users.js';
+export interface KernelPort {
+    postMessage(message: unknown, transfer?: Transferable[]): void;
+    addEventListener(type: 'message', handler: (event: MessageEvent) => void): void;
+}
+export interface InitRequest {
+    id: number;
+    op: 'init';
+    root?: FileSystemDirectoryHandle;
+    modules?: string;
+    commands?: {
+        append?: readonly string[];
+    };
+    env?: Record<string, string>;
+    metadata?: string | false;
+    media?: string | false;
+    ca?: string | false;
+    transport?: RealmTransportTraits;
+    uplink?: {
+        traits: UplinkTraits;
+        routes?: RouteTable;
+    };
+    hostfs?: boolean;
+    hostname?: string;
+    users?: UsersMode;
+    protect?: ProtectInit;
+    denials?: boolean;
+    sealed?: boolean;
+    clipboard?: boolean;
+    approve?: boolean;
+    processMounts?: boolean | 'ask';
+    cdp?: boolean;
+    facades?: Record<string, {
+        port: number;
+        hook?: boolean;
+    }>;
+}
+export interface RunRequest {
+    id: number;
+    op: 'run';
+    argv: string[];
+    options: Omit<RunOptions, 'onStdout' | 'onStderr'>;
+}
+export interface OpenTerminalRequest {
+    id: number;
+    op: 'open-terminal';
+    argv: string[];
+    options: Omit<TerminalOptions, 'onData'>;
+}
+export type TerminalAction = {
+    action: 'write';
+    bytes: Uint8Array;
+} | {
+    action: 'resize';
+    cols: number;
+    rows: number;
+} | {
+    action: 'signal';
+    signal: string;
+} | {
+    action: 'close';
+};
+export type TerminalRequest = {
+    id: number;
+    op: 'terminal';
+    terminal: number;
+} & TerminalAction;
+export interface ConnectRequest {
+    id: number;
+    op: 'connect';
+    user?: string | number;
+    tag?: string;
+}
+export type UsersRequest = {
+    id: number;
+    op: 'users-add';
+    user: AddUser;
+} | {
+    id: number;
+    op: 'users-remove';
+    name: string;
+    options?: RemoveUser;
+} | {
+    id: number;
+    op: 'users-list';
+} | {
+    id: number;
+    op: 'groups-list';
+} | {
+    id: number;
+    op: 'groups-add-member' | 'groups-remove-member';
+    group: string;
+    user: string;
+};
+export interface RoutesRequest {
+    id: number;
+    op: 'routes';
+    routes: RouteTable;
+}
+export interface TraitsRequest {
+    id: number;
+    op: 'transport-traits';
+    traits?: RealmTransportTraits;
+}
+export type MountRequest = {
+    id: number;
+    op: 'mount';
+    spec: MountSpec;
+} | {
+    id: number;
+    op: 'umount';
+    target: string;
+} | {
+    id: number;
+    op: 'mounts';
+} | {
+    id: number;
+    op: 'insert';
+    target: string;
+    source?: string;
+    handle: MediumHandle;
+};
+export interface DialRequest {
+    id: number;
+    op: 'dial';
+    port: number;
+    host?: string;
+}
+export type AttestRequest = {
+    id: number;
+    op: 'attest';
+    path: string;
+} | {
+    id: number;
+    op: 'chmod';
+    path: string;
+    mode: number;
+} | {
+    id: number;
+    op: 'integrity-revoke';
+    path?: string;
+} | {
+    id: number;
+    op: 'watch-files';
+    paths: string[];
+} | {
+    id: number;
+    op: 'unwatch-files';
+    watch: number;
+};
+export interface FileChanged {
+    fileChanged: {
+        watch: number;
+        path: string;
+    };
+}
+export type KernelRequest = AttestRequest | InitRequest | RunRequest | OpenTerminalRequest | TerminalRequest | ConnectRequest | UsersRequest | MountRequest | DialRequest | RoutesRequest | TraitsRequest;
+type WithoutId<T> = T extends unknown ? Omit<T, 'id'> : never;
+export type KernelCall = WithoutId<KernelRequest>;
+export declare function inOpfs(deps: ServeDeps, root: FileSystemDirectoryHandle): Promise<boolean>;
+export interface ServeDeps {
+    storage: () => Promise<FileSystemDirectoryHandle>;
+    syncAccess?: boolean;
+    createWorker: () => WasmWorkerLike;
+    createDriverWorker?: () => WasmWorkerLike;
+    metadata?: (name: string) => Promise<MetaStore>;
+    media?: (name: string) => Promise<MediaStore>;
+    locks?: LockManagerLike | null;
+}
+export declare function signalNumber(name: string): number;
+export interface GrantReply {
+    id: number;
+    grant?: HostfsGrant | HostfsPortGrant;
+    error?: string;
+}
+export declare function serveKernel(port: KernelPort, deps: ServeDeps): void;
+export {};

package/dist/types/sudo-command.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from './commands.js';
+export declare const SUDO_PATH = "/usr/bin/sudo";
+export declare const SUDO_COMMAND: Command;
+export declare const SUDO_SOURCE: string;

package/dist/types/sudo.d.ts

@@ -0,0 +1,105 @@
+import type { KernelFs, UsersMode } from './fs/types.js';
+import type { Cred } from './kernel/cred.js';
+import { type UserDb } from './users.js';
+export declare const SUDOERS = "/etc/sudoers";
+export declare const SUDOERS_D = "/etc/sudoers.d";
+export declare const SECURE_PATH = "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin";
+export declare const DEFAULT_SUDOERS = "%sudo Cmnd *\n";
+export declare const SUDO_TIMEOUT_MS = 300000;
+export interface SudoRequest {
+    id: string;
+    kind: 'sudo';
+    user: string;
+    uid: number;
+    target: string;
+    argv: string[];
+    path: string;
+    cwd: string;
+    pid: number;
+    tag?: string;
+    tty?: string;
+    createdAt: number;
+    expiresAt: number;
+    always: boolean;
+}
+export type SudoAnswer = 'once' | 'always' | 'deny';
+export type ApproveHook = (req: SudoRequest, options: {
+    signal: AbortSignal;
+}) => SudoAnswer | Promise<SudoAnswer>;
+export interface SudoCall {
+    op: 'proc-sudo';
+    args: string[];
+    cwd: string;
+    term?: string;
+}
+export interface SudoGrant {
+    file: string;
+    argv: string[];
+    env: Record<string, string>;
+    cwd: string;
+    cred: Cred;
+    caller: Cred;
+}
+export type SudoResult = {
+    error: string;
+    errno: string;
+} | {
+    list: string;
+} | {
+    run: string[];
+} | {
+    grant: SudoGrant;
+};
+export interface SudoCaller {
+    cred: Cred;
+    pid: number;
+    tag?: string | undefined;
+    tty?: string | null | undefined;
+}
+interface Rule {
+    nopasswd: boolean;
+    who: string;
+    target: string;
+    cwd?: string;
+    cmnd: string[] | '*';
+}
+export interface SudoOptions {
+    fs: KernelFs;
+    users: UserDb;
+    mode: UsersMode;
+    hostname: string;
+    env: () => Record<string, string>;
+    pnpmHome: string;
+    backing?: (path: string, cwd: string) => Promise<string[] | undefined>;
+    approve?: ApproveHook | undefined;
+    timeoutMs?: number | undefined;
+    warn?: (message: string) => void;
+}
+export declare function splitWords(text: string): string[] | undefined;
+export declare function quoteWord(word: string): string;
+export declare function parseRule(line: string): Rule | null | undefined;
+export declare class Sudo {
+    private readonly o;
+    private readonly warned;
+    private readonly pending;
+    private next;
+    constructor(options: SudoOptions);
+    private warn;
+    provision(): Promise<void>;
+    trusted(path: string): Promise<boolean>;
+    private policyFile;
+    private policy;
+    private groupIds;
+    private applies;
+    private lookup;
+    private canonical;
+    reachable(cred: Cred, cwd: string): Promise<boolean>;
+    private untrusted;
+    private locate;
+    request(caller: SudoCaller, call: SudoCall, signal: AbortSignal): Promise<SudoResult>;
+    private listed;
+    private ask;
+    private remember;
+    private grant;
+}
+export {};

package/dist/types/testing.d.ts

@@ -0,0 +1,46 @@
+import type { RouteTable } from './kernel/net/routes.js';
+import { type NetworkUplink, type ResolveAnswer, type ResolveFamily, type UplinkConn, type UplinkDatagram, type UplinkDial, type UplinkMessage, type UplinkUdp, type UplinkUdpOpen, type UplinkUnreachable } from './kernel/net/uplink.js';
+export { type CronClock, type FakeCronClock, fakeCronClock } from './cron/clock.js';
+export type { NetworkUplink, ResolveAnswer, ResolveFamily, RouteTable, UplinkConn, UplinkDatagram, UplinkDial, UplinkMessage, UplinkUdp, UplinkUdpOpen, UplinkUnreachable, };
+export type FakeDatagramPeer = (bytes: Uint8Array) => Uint8Array | readonly Uint8Array[] | {
+    error: string;
+} | undefined;
+export interface FakePeerSocket {
+    read(): Promise<Uint8Array | null>;
+    write(bytes: Uint8Array): void;
+    end(): void;
+    reset(code?: string): void;
+    readonly buffered: number;
+    drained(): Promise<void>;
+    readonly closed: Promise<void>;
+}
+export type FakePeer = ((socket: FakePeerSocket) => void) | {
+    error: string;
+} | {
+    hang: true;
+};
+export interface FakeUplinkOptions {
+    names?: Readonly<Record<string, string[] | ResolveAnswer>>;
+    routes?: RouteTable;
+    ipv6?: boolean;
+    peers?: Readonly<Record<string, FakePeer>>;
+    datagrams?: Readonly<Record<string, FakeDatagramPeer>>;
+    address?: string;
+}
+export interface FakeUplink extends NetworkUplink {
+    readonly asked: Array<{
+        name: string;
+        family: ResolveFamily;
+    }>;
+    readonly dialled: Array<{
+        host: string;
+        port: number;
+    }>;
+    readonly sent: Array<{
+        host: string;
+        port: number;
+        bytes: Uint8Array;
+    }>;
+    udp(req: UplinkUdpOpen): Promise<UplinkUdp>;
+}
+export declare function fakeUplink(options?: FakeUplinkOptions): FakeUplink;

package/dist/types/transport.d.ts

@@ -0,0 +1,25 @@
+import type { TransportCall, TransportReply } from './kernel/net/remote-transport.js';
+import type { HeaderList, RealmRedirectHop, RealmTransport, RealmTransportExit, RealmTransportRequest, RealmTransportResponse, RealmTransportTraits, RealmWebSocket, RealmWebSocketRequest } from './kernel/net/transport.js';
+import { type WebSocketConstructor } from './websocket-transport.js';
+export type { HeaderList, RealmRedirectHop as NetworkRedirectHop, RealmTransport as NetworkTransport, RealmTransportExit as NetworkExit, RealmTransportRequest as NetworkRequest, RealmTransportResponse as NetworkResponse, RealmTransportTraits as NetworkTraits, RealmWebSocket as NetworkWebSocket, RealmWebSocketRequest as NetworkWebSocketRequest, };
+export interface FetchTransportOptions {
+    fetch?: typeof globalThis.fetch;
+    maxRequestBody?: number;
+    hint?: string;
+    bodyIdleMs?: number;
+    webSocket?: boolean | WebSocketConstructor;
+    webSocketHeaders?: boolean;
+    redirect?: 'follow' | 'manual';
+}
+export declare const SEND_BUFFER: number;
+export declare function fetchTransport(options?: FetchTransportOptions): RealmTransport;
+export interface TransportPeer {
+    postMessage(message: TransportReply, transfer?: Transferable[]): void;
+}
+export interface TransportServer {
+    answer(call: TransportCall): void;
+    close(): void;
+}
+export declare function serveTransport(peer: TransportPeer, transport: RealmTransport, { closeWaitMs }?: {
+    closeWaitMs?: number;
+}): TransportServer;

package/dist/types/users.d.ts

@@ -0,0 +1,86 @@
+import type { KernelFs } from './fs/types.js';
+import { type Cred } from './kernel/cred.js';
+export declare const PASSWD = "/etc/passwd";
+export declare const GROUP = "/etc/group";
+export declare const DEFAULT_PASSWD = "root:x:0:0:root:/root:/bin/bash\nnobody:x:65534:65534:nobody:/nonexistent:/usr/sbin/nologin\n";
+export declare const DEFAULT_GROUP = "root:x:0:\nsudo:x:27:\nusers:x:100:\nnogroup:x:65534:\n";
+export declare const SYSTEM_PNPM_HOME = "/usr/local/share/pnpm";
+export declare const PNPM_CONFIG = "minimumReleaseAge: 1440\n";
+export interface Account {
+    name: string;
+    uid: number;
+    gid: number;
+    home: string;
+    shell: string;
+    groups: number[];
+    umask?: number;
+}
+export interface AddUser {
+    name: string;
+    home?: string;
+    groups?: string[];
+    umask?: number;
+    homeGroup?: string;
+    homeMode?: number;
+}
+export interface Group {
+    name: string;
+    gid: number;
+    members: string[];
+}
+export interface RemoveUser {
+    keepHome?: boolean;
+}
+interface PasswdRow {
+    name: string;
+    uid: number;
+    gid: number;
+    gecos: string;
+    home: string;
+    shell: string;
+}
+interface GroupRow {
+    name: string;
+    gid: number;
+    members: string[];
+}
+type Rows<T> = Array<T | string>;
+export declare function parsePasswd(text: string): Rows<PasswdRow>;
+export declare function parseGroup(text: string): Rows<GroupRow>;
+export declare function credOf(account: Account): Cred;
+export declare function pnpmHomeOf(account: Account, system?: string): string;
+export declare function userEnv(account: Account, system?: string): Record<string, string>;
+export declare class UserDb {
+    private readonly fs;
+    private readonly owners;
+    private readonly umasks;
+    private writing;
+    private stable;
+    private commits;
+    constructor(fs: KernelFs, owners?: boolean);
+    private stampHome;
+    private umaskFor;
+    private realDir;
+    private read;
+    private texts;
+    private tables;
+    private provision;
+    private commit;
+    private serial;
+    ensure(): Promise<void>;
+    private account;
+    lookup(user: string | number): Promise<Account | undefined>;
+    ttyGroup(): Promise<number | undefined>;
+    lookupTerminal(user: string | number): Promise<{
+        account: Account;
+        tty: number | undefined;
+    } | undefined>;
+    list(): Promise<Account[]>;
+    add(options: AddUser): Promise<Account>;
+    groups(): Promise<Group[]>;
+    addMember(group: string, user: string): Promise<Group>;
+    removeMember(group: string, user: string): Promise<Group>;
+    private member;
+    remove(name: string, options?: RemoveUser): Promise<boolean>;
+}
+export {};

package/dist/types/version.d.ts

@@ -0,0 +1,3 @@
+export declare const KERNEL_VERSION: string;
+export declare const OS_RELEASE = "6.0.0-slicc";
+export declare function procVersion(): string;

package/dist/types/websocket-transport.d.ts

@@ -0,0 +1,12 @@
+import type { RealmWebSocket, RealmWebSocketRequest } from './kernel/net/transport.js';
+export interface WebSocketLike {
+    binaryType: string;
+    readonly protocol: string;
+    readonly bufferedAmount: number;
+    send(data: string | ArrayBufferView): void;
+    close(code?: number, reason?: string): void;
+    addEventListener(type: string, listener: (event: never) => void): void;
+}
+export type WebSocketConstructor = new (url: string, init?: unknown) => WebSocketLike;
+export declare function sendableClose(code?: number): number;
+export declare function openWebSocket(Socket: WebSocketConstructor, request: RealmWebSocketRequest, withHeaders: boolean): Promise<RealmWebSocket>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-ecoverse/slicc-kernel",
-  "version": "1.102.5",
+  "version": "1.103.0",
   "description": "SLICC's wasm-realm kernel: run Emscripten programs in the browser against OPFS, with fork, spawn, pipes and waitpid",
   "type": "module",
   "license": "Apache-2.0",
@@ -21,12 +21,28 @@
     "access": "public",
     "provenance": true
   },
+  "types": "./dist/types/index.d.ts",
   "exports": {
-    ".": "./dist/index.js",
-    "./node": "./dist/node.js",
-    "./driver": "./dist/driver.js",
-    "./testing": "./dist/testing.js",
-    "./meta": "./dist/meta.js"
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./node": {
+      "types": "./dist/types/node.d.ts",
+      "default": "./dist/node.js"
+    },
+    "./driver": {
+      "types": "./dist/types/driver.d.ts",
+      "default": "./dist/driver.js"
+    },
+    "./testing": {
+      "types": "./dist/types/testing.d.ts",
+      "default": "./dist/testing.js"
+    },
+    "./meta": {
+      "types": "./dist/types/meta.d.ts",
+      "default": "./dist/meta.js"
+    }
   },
   "files": [
     "dist"