@easonwumac/computer-linker 0.1.2

package/dist/service.d.ts

@@ -0,0 +1,125 @@
+import { type LocalPortConfig } from "./permissions.js";
+export type ServicePlatform = "linux" | "macos" | "windows";
+export type ServiceFormat = "profile" | "manifest";
+export interface ServiceProfileOptions {
+    platform?: ServicePlatform;
+    nodePath?: string;
+    cliPath?: string;
+    serviceName?: string;
+    configDirectory?: string;
+    outputDir?: string;
+}
+export interface ServiceFileSet {
+    profile: string;
+    manifest: string;
+    install: string;
+    uninstall: string;
+}
+export interface ServiceProfile {
+    kind: "computer-linker-service-profile";
+    schemaVersion: 1;
+    platform: ServicePlatform;
+    serviceName: string;
+    label: string;
+    command: string[];
+    commandDisplay: string;
+    configDir: string;
+    configPath: string;
+    manifestPath: string;
+    manifest: string;
+    installCommands: string[];
+    uninstallCommands: string[];
+    statusCommands: string[];
+    startCommands: string[];
+    stopCommands: string[];
+    logCommands: string[];
+    logFiles: {
+        stdout: string;
+        stderr: string;
+    };
+    notes: string[];
+}
+export interface WrittenServiceProfile {
+    kind: "computer-linker-service-files";
+    outputDir: string;
+    platform: ServicePlatform;
+    files: ServiceFileSet;
+}
+export interface ServiceStatus {
+    kind: "computer-linker-service-status";
+    schemaVersion: 1;
+    platform: ServicePlatform;
+    serviceName: string;
+    label: string;
+    configDir: string;
+    configPath: string;
+    manifestPath: string;
+    manifestExists: boolean | null;
+    commandDisplay: string;
+    statusCommands: string[];
+    installCommands: string[];
+    uninstallCommands: string[];
+    startCommands: string[];
+    stopCommands: string[];
+    logCommands: string[];
+    logFiles: {
+        stdout: string;
+        stderr: string;
+    };
+    notes: string[];
+}
+export type ServicePlanAction = "install" | "uninstall" | "start" | "stop";
+export interface ServicePlan {
+    kind: "computer-linker-service-plan";
+    schemaVersion: 1;
+    action: ServicePlanAction;
+    dryRun: boolean;
+    platform: ServicePlatform;
+    serviceName: string;
+    label: string;
+    requiresElevation: boolean;
+    commands: string[];
+    recommendedProfileCommand: string;
+    notes: string[];
+}
+export interface ServiceLogReport {
+    kind: "computer-linker-service-logs";
+    schemaVersion: 1;
+    platform: ServicePlatform;
+    serviceName: string;
+    label: string;
+    logFiles: {
+        stdout: string;
+        stderr: string;
+    };
+    stdout: {
+        exists: boolean;
+        path: string;
+        tail: string;
+    };
+    stderr: {
+        exists: boolean;
+        path: string;
+        tail: string;
+    };
+    commands: string[];
+    notes: string[];
+}
+export declare function serviceProfile(config: LocalPortConfig, options?: ServiceProfileOptions): ServiceProfile;
+export declare function serviceProfileOutput(config: LocalPortConfig, options?: ServiceProfileOptions & {
+    format?: ServiceFormat;
+}): string;
+export declare function writeServiceProfileFiles(config: LocalPortConfig, options?: ServiceProfileOptions): WrittenServiceProfile;
+export declare function serviceStatus(config: LocalPortConfig, options?: ServiceProfileOptions): ServiceStatus;
+export declare function servicePlan(config: LocalPortConfig, action: ServicePlanAction, options?: ServiceProfileOptions & {
+    dryRun?: boolean;
+}): ServicePlan;
+export declare function defaultServiceOutputDir(options?: ServiceProfileOptions): string;
+export declare function serviceLogs(config: LocalPortConfig, options?: ServiceProfileOptions & {
+    lines?: number;
+}): ServiceLogReport;
+export declare function formatServiceStatus(status: ServiceStatus): string;
+export declare function formatServicePlan(plan: ServicePlan): string;
+export declare function formatServiceLogs(report: ServiceLogReport): string;
+export declare function parseServicePlatform(value: string | undefined): ServicePlatform;
+export declare function parseServiceFormat(value: string | undefined): ServiceFormat;

package/dist/service.js

@@ -0,0 +1,486 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join, resolve } from "node:path";
+import { configDir } from "./config.js";
+import { expandHomePath } from "./permissions.js";
+export function serviceProfile(config, options = {}) {
+    const platform = options.platform ?? currentServicePlatform();
+    const serviceName = sanitizeServiceName(options.serviceName ?? "computer-linker");
+    const label = platform === "macos" ? `com.computer-linker.${serviceName}` : serviceName;
+    const nodePath = resolve(options.nodePath ?? process.execPath);
+    const cliPath = resolve(options.cliPath ?? process.argv[1] ?? "dist/cli.js");
+    const serviceConfigDir = resolve(expandHomePath(options.configDirectory ?? configDir()));
+    const command = [nodePath, cliPath, "serve", "--transport", "http"];
+    const manifestPath = defaultManifestPath(platform, label, serviceName);
+    const logFiles = serviceLogFiles(serviceConfigDir);
+    const manifest = serviceManifest(platform, {
+        label,
+        serviceName,
+        command,
+        configDirectory: serviceConfigDir,
+    });
+    return {
+        kind: "computer-linker-service-profile",
+        schemaVersion: 1,
+        platform,
+        serviceName,
+        label,
+        command,
+        commandDisplay: command.map(shellQuote).join(" "),
+        configDir: serviceConfigDir,
+        configPath: join(serviceConfigDir, "config.json"),
+        manifestPath,
+        manifest,
+        installCommands: installCommands(platform, manifestPath, label, serviceName),
+        uninstallCommands: uninstallCommands(platform, manifestPath, label, serviceName),
+        statusCommands: statusCommands(platform, label, serviceName),
+        startCommands: startCommands(platform, label, serviceName),
+        stopCommands: stopCommands(platform, label, serviceName),
+        logCommands: logCommands(platform, label, serviceName, logFiles),
+        logFiles,
+        notes: serviceNotes(platform),
+    };
+}
+export function serviceProfileOutput(config, options = {}) {
+    const profile = serviceProfile(config, options);
+    return options.format === "manifest"
+        ? profile.manifest
+        : `${JSON.stringify(profile, null, 2)}\n`;
+}
+export function writeServiceProfileFiles(config, options = {}) {
+    if (!options.outputDir || options.outputDir.startsWith("--")) {
+        throw new Error("service profile --output-dir requires a directory path");
+    }
+    const outputDir = resolve(expandHomePath(options.outputDir));
+    const profile = serviceProfile(config, options);
+    const extension = profile.platform === "macos" ? "plist" : profile.platform === "linux" ? "service" : "ps1";
+    const files = {
+        profile: join(outputDir, "service-profile.json"),
+        manifest: join(outputDir, `${profile.serviceName}.${extension}`),
+        install: join(outputDir, installScriptName(profile.platform)),
+        uninstall: join(outputDir, uninstallScriptName(profile.platform)),
+    };
+    mkdirSync(outputDir, { recursive: true });
+    writeFileSync(files.profile, `${JSON.stringify(profile, null, 2)}\n`, { mode: 0o600 });
+    writeFileSync(files.manifest, profile.manifest, { mode: 0o600 });
+    writeFileSync(files.install, installScriptBody(profile, files), { mode: 0o700 });
+    writeFileSync(files.uninstall, uninstallScriptBody(profile), { mode: 0o700 });
+    return {
+        kind: "computer-linker-service-files",
+        outputDir,
+        platform: profile.platform,
+        files,
+    };
+}
+export function serviceStatus(config, options = {}) {
+    const profile = serviceProfile(config, options);
+    return {
+        kind: "computer-linker-service-status",
+        schemaVersion: 1,
+        platform: profile.platform,
+        serviceName: profile.serviceName,
+        label: profile.label,
+        configDir: profile.configDir,
+        configPath: profile.configPath,
+        manifestPath: profile.manifestPath,
+        manifestExists: profile.platform === "windows" ? null : existsSync(profile.manifestPath),
+        commandDisplay: profile.commandDisplay,
+        statusCommands: profile.statusCommands,
+        installCommands: profile.installCommands,
+        uninstallCommands: profile.uninstallCommands,
+        startCommands: profile.startCommands,
+        stopCommands: profile.stopCommands,
+        logCommands: profile.logCommands,
+        logFiles: profile.logFiles,
+        notes: profile.notes,
+    };
+}
+export function servicePlan(config, action, options = {}) {
+    const profile = serviceProfile(config, options);
+    const commands = action === "install"
+        ? profile.installCommands
+        : action === "uninstall"
+            ? profile.uninstallCommands
+            : action === "start"
+                ? profile.startCommands
+                : profile.stopCommands;
+    return {
+        kind: "computer-linker-service-plan",
+        schemaVersion: 1,
+        action,
+        dryRun: options.dryRun ?? true,
+        platform: profile.platform,
+        serviceName: profile.serviceName,
+        label: profile.label,
+        requiresElevation: serviceActionRequiresElevation(profile.platform, action),
+        commands,
+        recommendedProfileCommand: `computer-linker service profile --platform ${profile.platform} --output-dir ${shellQuote(defaultServiceOutputDir(options))}`,
+        notes: [
+            options.dryRun === false
+                ? "This action may change the OS service manager."
+                : "Dry run only. No service files were written and no OS service was changed.",
+            ...profile.notes,
+        ],
+    };
+}
+export function defaultServiceOutputDir(options = {}) {
+    const serviceConfigDir = resolve(expandHomePath(options.configDirectory ?? configDir()));
+    return resolve(expandHomePath(options.outputDir ?? join(serviceConfigDir, "service-profile")));
+}
+export function serviceLogs(config, options = {}) {
+    const profile = serviceProfile(config, options);
+    const lines = normalizeLogLines(options.lines);
+    return {
+        kind: "computer-linker-service-logs",
+        schemaVersion: 1,
+        platform: profile.platform,
+        serviceName: profile.serviceName,
+        label: profile.label,
+        logFiles: profile.logFiles,
+        stdout: readLogTail(profile.logFiles.stdout, lines),
+        stderr: readLogTail(profile.logFiles.stderr, lines),
+        commands: profile.logCommands,
+        notes: serviceLogNotes(profile.platform),
+    };
+}
+export function formatServiceStatus(status) {
+    const manifest = status.manifestExists === null
+        ? "service-manager"
+        : status.manifestExists ? "present" : "missing";
+    return [
+        `Computer Linker service status (${status.platform})`,
+        `serviceName: ${status.serviceName}`,
+        `label: ${status.label}`,
+        `configPath: ${status.configPath}`,
+        `manifestPath: ${status.manifestPath}`,
+        `manifest: ${manifest}`,
+        `command: ${status.commandDisplay}`,
+        "status commands:",
+        ...status.statusCommands.map((command) => `  ${command}`),
+        "daily commands:",
+        ...status.startCommands.map((command) => `  start: ${command}`),
+        ...status.stopCommands.map((command) => `  stop: ${command}`),
+        ...status.logCommands.map((command) => `  logs: ${command}`),
+        "notes:",
+        ...status.notes.map((note) => `  - ${note}`),
+    ].join("\n") + "\n";
+}
+export function formatServicePlan(plan) {
+    return [
+        `Computer Linker service ${plan.action}${plan.dryRun ? " dry run" : ""} (${plan.platform})`,
+        `serviceName: ${plan.serviceName}`,
+        `requiresElevation: ${plan.requiresElevation ? "yes" : "no"}`,
+        `profileCommand: ${plan.recommendedProfileCommand}`,
+        "commands:",
+        ...plan.commands.map((command) => `  ${command}`),
+        "notes:",
+        ...plan.notes.map((note) => `  - ${note}`),
+    ].join("\n") + "\n";
+}
+export function formatServiceLogs(report) {
+    const lines = [
+        `Computer Linker service logs (${report.platform})`,
+        `serviceName: ${report.serviceName}`,
+        `stdout: ${report.stdout.path} (${report.stdout.exists ? "present" : "missing"})`,
+        report.stdout.tail ? report.stdout.tail : "  (no stdout log content)",
+        `stderr: ${report.stderr.path} (${report.stderr.exists ? "present" : "missing"})`,
+        report.stderr.tail ? report.stderr.tail : "  (no stderr log content)",
+        "commands:",
+        ...report.commands.map((command) => `  ${command}`),
+        "notes:",
+        ...report.notes.map((note) => `  - ${note}`),
+    ];
+    return `${lines.join("\n")}\n`;
+}
+export function parseServicePlatform(value) {
+    if (!value)
+        return currentServicePlatform();
+    if (value === "linux" || value === "macos" || value === "windows")
+        return value;
+    throw new Error("service --platform must be one of: linux, macos, windows");
+}
+export function parseServiceFormat(value) {
+    if (!value)
+        return "profile";
+    if (value === "profile" || value === "manifest")
+        return value;
+    throw new Error("service --format must be one of: profile, manifest");
+}
+function currentServicePlatform() {
+    if (process.platform === "darwin")
+        return "macos";
+    if (process.platform === "win32")
+        return "windows";
+    return "linux";
+}
+function defaultManifestPath(platform, label, serviceName) {
+    if (platform === "macos")
+        return join(homedir(), "Library", "LaunchAgents", `${label}.plist`);
+    if (platform === "windows")
+        return `${serviceName} Windows Service`;
+    return `/etc/systemd/system/${serviceName}.service`;
+}
+function serviceManifest(platform, input) {
+    if (platform === "macos")
+        return launchdPlist(input);
+    if (platform === "windows")
+        return windowsServiceScript(input);
+    return systemdUnit(input);
+}
+function systemdUnit(input) {
+    return `[Unit]
+Description=Computer Linker HTTP MCP server
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${input.command.map(systemdEscapeArg).join(" ")}
+Restart=on-failure
+RestartSec=3
+Environment=COMPUTER_LINKER_CONFIG_DIR=${systemdEscapeArg(input.configDirectory)}
+
+[Install]
+WantedBy=multi-user.target
+`;
+}
+function launchdPlist(input) {
+    const args = input.command.map((arg) => `    <string>${xmlEscape(arg)}</string>`).join("\n");
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${xmlEscape(input.label)}</string>
+  <key>ProgramArguments</key>
+  <array>
+${args}
+  </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>COMPUTER_LINKER_CONFIG_DIR</key>
+    <string>${xmlEscape(input.configDirectory)}</string>
+  </dict>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${xmlEscape(join(input.configDirectory, "service.out.log"))}</string>
+  <key>StandardErrorPath</key>
+  <string>${xmlEscape(join(input.configDirectory, "service.err.log"))}</string>
+</dict>
+</plist>
+`;
+}
+function windowsServiceScript(input) {
+    const logFiles = serviceLogFiles(input.configDirectory);
+    const command = [
+        `if not exist ${windowsQuote(input.configDirectory)} mkdir ${windowsQuote(input.configDirectory)}`,
+        `set "COMPUTER_LINKER_CONFIG_DIR=${input.configDirectory}"`,
+        `${input.command.map(windowsQuote).join(" ")} >> ${windowsQuote(logFiles.stdout)} 2>> ${windowsQuote(logFiles.stderr)}`,
+    ].join(" && ");
+    const binPath = `${windowsQuote(process.env.ComSpec ?? "C:\\Windows\\System32\\cmd.exe")} /d /s /c ${windowsQuote(command)}`;
+    return `$ErrorActionPreference = "Stop"
+sc.exe create ${powershellQuote(input.serviceName)} binPath= ${powershellQuote(binPath)} start= auto DisplayName= "Computer Linker"
+sc.exe description ${powershellQuote(input.serviceName)} "Computer Linker HTTP MCP server"
+sc.exe start ${powershellQuote(input.serviceName)}
+`;
+}
+function installCommands(platform, manifestPath, label, serviceName) {
+    if (platform === "macos") {
+        return [
+            `mkdir -p ${shellQuote(dirnamePath(manifestPath))}`,
+            `cp ./service-profile/${basename(manifestPath)} ${shellQuote(manifestPath)}`,
+            `launchctl bootstrap gui/$(id -u) ${shellQuote(manifestPath)}`,
+            `launchctl enable gui/$(id -u)/${shellQuote(label)}`,
+        ];
+    }
+    if (platform === "windows") {
+        return [
+            "Run install-service.ps1 from an elevated PowerShell prompt.",
+            `Get-Service ${serviceName}`,
+        ];
+    }
+    return [
+        `sudo cp ./service-profile/${basename(manifestPath)} ${shellQuote(manifestPath)}`,
+        "sudo systemctl daemon-reload",
+        `sudo systemctl enable --now ${shellQuote(serviceName)}`,
+    ];
+}
+function uninstallCommands(platform, manifestPath, label, serviceName) {
+    if (platform === "macos") {
+        return [
+            `launchctl bootout gui/$(id -u)/${shellQuote(label)} || true`,
+            `rm -f ${shellQuote(manifestPath)}`,
+        ];
+    }
+    if (platform === "windows") {
+        return [
+            `sc.exe stop ${powershellQuote(serviceName)}`,
+            `sc.exe delete ${powershellQuote(serviceName)}`,
+        ];
+    }
+    return [
+        `sudo systemctl disable --now ${shellQuote(serviceName)}`,
+        `sudo rm -f ${shellQuote(manifestPath)}`,
+        "sudo systemctl daemon-reload",
+    ];
+}
+function statusCommands(platform, label, serviceName) {
+    if (platform === "macos")
+        return [`launchctl print gui/$(id -u)/${label}`];
+    if (platform === "windows")
+        return [`Get-Service ${serviceName}`, `sc.exe query ${serviceName}`];
+    return [`systemctl status ${serviceName}`, `journalctl -u ${serviceName} -n 100 --no-pager`];
+}
+function startCommands(platform, label, serviceName) {
+    if (platform === "macos")
+        return [`launchctl kickstart -k gui/$(id -u)/${label}`];
+    if (platform === "windows")
+        return [`sc.exe start ${powershellQuote(serviceName)}`];
+    return [`sudo systemctl start ${shellQuote(serviceName)}`];
+}
+function stopCommands(platform, label, serviceName) {
+    if (platform === "macos")
+        return [`launchctl bootout gui/$(id -u)/${shellQuote(label)}`];
+    if (platform === "windows")
+        return [`sc.exe stop ${powershellQuote(serviceName)}`];
+    return [`sudo systemctl stop ${shellQuote(serviceName)}`];
+}
+function logCommands(platform, label, serviceName, logFiles) {
+    if (platform === "linux")
+        return [`journalctl -u ${serviceName} -n 100 --no-pager`];
+    if (platform === "windows") {
+        return [
+            `Get-Content -Tail 100 ${powershellQuote(logFiles.stdout)}`,
+            `Get-Content -Tail 100 ${powershellQuote(logFiles.stderr)}`,
+        ];
+    }
+    return [
+        `tail -n 100 ${shellQuote(logFiles.stdout)}`,
+        `tail -n 100 ${shellQuote(logFiles.stderr)}`,
+        `launchctl print gui/$(id -u)/${label}`,
+    ];
+}
+function serviceNotes(platform) {
+    const common = [
+        "Run `computer-linker init` before installing so ownerToken is configured.",
+        "The service starts HTTP mode on the configured host and port.",
+        "Use Tailscale Serve, Cloudflare Access, or equivalent controls before exposing it beyond loopback.",
+    ];
+    if (platform === "windows") {
+        return [...common, "Windows Service creation requires an elevated PowerShell prompt."];
+    }
+    if (platform === "linux") {
+        return [...common, "systemd install commands require sudo."];
+    }
+    return [...common, "launchd runs this as the current user through ~/Library/LaunchAgents."];
+}
+function serviceLogNotes(platform) {
+    if (platform === "linux") {
+        return ["Linux systemd services usually log to journald; use the printed journalctl command when local log files are empty."];
+    }
+    return ["Logs are written by the generated service profile after the service starts."];
+}
+function serviceLogFiles(serviceConfigDir) {
+    return {
+        stdout: join(serviceConfigDir, "service.out.log"),
+        stderr: join(serviceConfigDir, "service.err.log"),
+    };
+}
+function readLogTail(path, lines) {
+    if (!existsSync(path))
+        return { exists: false, path, tail: "" };
+    const content = readFileSync(path, "utf8");
+    return {
+        exists: true,
+        path,
+        tail: tailLines(content, lines),
+    };
+}
+function tailLines(content, lines) {
+    const items = content.split(/\r?\n/);
+    const hasTrailingNewline = items.length > 0 && items.at(-1) === "";
+    const trimmed = hasTrailingNewline ? items.slice(0, -1) : items;
+    return trimmed.slice(-lines).join("\n");
+}
+function normalizeLogLines(value) {
+    if (!Number.isFinite(value ?? 100))
+        return 100;
+    return Math.max(1, Math.min(1000, Math.floor(value ?? 100)));
+}
+function serviceActionRequiresElevation(platform, action) {
+    if (platform === "macos")
+        return false;
+    if (platform === "windows")
+        return action === "install" || action === "uninstall";
+    return true;
+}
+function sanitizeServiceName(value) {
+    const sanitized = value.trim().toLowerCase().replace(/[^a-z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "");
+    return sanitized || "computer-linker";
+}
+function shellQuote(value) {
+    if (/^[A-Za-z0-9_./:@%+=,-]+$/.test(value))
+        return value;
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function systemdEscapeArg(value) {
+    return value.replace(/([\\s\\\\\"'`$])/g, "\\$1");
+}
+function windowsQuote(value) {
+    if (!/[\s"]/g.test(value))
+        return value;
+    return `"${value.replace(/"/g, '\\"')}"`;
+}
+function powershellQuote(value) {
+    return `'${value.replace(/'/g, "''")}'`;
+}
+function xmlEscape(value) {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&apos;");
+}
+function scriptBody(platform, commands) {
+    if (platform === "windows") {
+        return `$ErrorActionPreference = "Stop"\n${commands.join("\n")}\n`;
+    }
+    return `#!/usr/bin/env sh\nset -eu\n${commands.join("\n")}\n`;
+}
+function installScriptBody(profile, files) {
+    if (profile.platform === "windows")
+        return profile.manifest;
+    const scriptDir = "SCRIPT_DIR=$(CDPATH= cd -- \"$(dirname -- \"$0\")\" && pwd)";
+    if (profile.platform === "macos") {
+        return scriptBody("macos", [
+            scriptDir,
+            `mkdir -p ${shellQuote(dirnamePath(profile.manifestPath))}`,
+            `cp "$SCRIPT_DIR/${basename(files.manifest)}" ${shellQuote(profile.manifestPath)}`,
+            `launchctl bootstrap gui/$(id -u) ${shellQuote(profile.manifestPath)}`,
+            `launchctl enable gui/$(id -u)/${shellQuote(profile.label)}`,
+        ]);
+    }
+    return scriptBody("linux", [
+        scriptDir,
+        `sudo cp "$SCRIPT_DIR/${basename(files.manifest)}" ${shellQuote(profile.manifestPath)}`,
+        "sudo systemctl daemon-reload",
+        `sudo systemctl enable --now ${shellQuote(profile.serviceName)}`,
+    ]);
+}
+function uninstallScriptBody(profile) {
+    return scriptBody(profile.platform, profile.uninstallCommands);
+}
+function installScriptName(platform) {
+    return platform === "windows" ? "install-service.ps1" : "install-service.sh";
+}
+function uninstallScriptName(platform) {
+    return platform === "windows" ? "uninstall-service.ps1" : "uninstall-service.sh";
+}
+function dirnamePath(path) {
+    const index = path.lastIndexOf("/");
+    return index === -1 ? "." : path.slice(0, index);
+}

package/dist/sessions.d.ts

@@ -0,0 +1,26 @@
+export type SessionAuthType = "owner-token" | "oauth" | "loopback";
+export interface ActiveSession {
+    id: string;
+    idPrefix: string;
+    createdAt: string;
+    lastSeenAt: string;
+    authType: SessionAuthType;
+    requestCount: number;
+    clientId?: string;
+    clientName?: string;
+    userAgent?: string;
+    remoteAddress?: string;
+}
+export interface RegisterSessionInput {
+    id: string;
+    authType: SessionAuthType;
+    clientId?: string;
+    clientName?: string;
+    userAgent?: string;
+    remoteAddress?: string;
+}
+export declare function registerActiveSession(input: RegisterSessionInput): ActiveSession;
+export declare function touchActiveSession(id: string): void;
+export declare function closeActiveSession(id: string): void;
+export declare function listActiveSessions(): ActiveSession[];
+export declare function clearActiveSessionsForTest(): void;

package/dist/sessions.js

@@ -0,0 +1,34 @@
+const activeSessions = new Map();
+export function registerActiveSession(input) {
+    const now = new Date().toISOString();
+    const session = {
+        id: input.id,
+        idPrefix: input.id.slice(0, 8),
+        createdAt: now,
+        lastSeenAt: now,
+        authType: input.authType,
+        requestCount: 1,
+        clientId: input.clientId,
+        clientName: input.clientName,
+        userAgent: input.userAgent,
+        remoteAddress: input.remoteAddress,
+    };
+    activeSessions.set(input.id, session);
+    return session;
+}
+export function touchActiveSession(id) {
+    const session = activeSessions.get(id);
+    if (!session)
+        return;
+    session.lastSeenAt = new Date().toISOString();
+    session.requestCount += 1;
+}
+export function closeActiveSession(id) {
+    activeSessions.delete(id);
+}
+export function listActiveSessions() {
+    return Array.from(activeSessions.values()).sort((a, b) => b.lastSeenAt.localeCompare(a.lastSeenAt));
+}
+export function clearActiveSessionsForTest() {
+    activeSessions.clear();
+}