@codori/server 0.0.2 → 0.0.4

package/dist/service-adapters.d.ts

@@ -0,0 +1,39 @@
+import type { ServicePlatform, ServiceScope } from './service.js';
+export type ServiceCommand = {
+    command: string;
+    args: string[];
+};
+export type ServiceUnitDefinition = {
+    serviceName: string;
+    serviceFilePath: string;
+    serviceFileContents: string;
+};
+export type ServiceUnitInput = {
+    installId: string;
+    scope: ServiceScope;
+    launcherPath: string;
+    root: string;
+    metadataDirectory: string;
+    homeDir?: string;
+    userId?: number;
+};
+export declare const resolveServicePlatform: (platform?: NodeJS.Platform) => ServicePlatform;
+export declare const getDarwinServiceName: (installId: string) => string;
+export declare const getLinuxServiceName: (installId: string) => string;
+export declare const renderLaunchdPlist: ({ serviceName, launcherPath, root, metadataDirectory }: Omit<ServiceUnitDefinition, "serviceFilePath" | "serviceFileContents"> & {
+    launcherPath: string;
+    root: string;
+    metadataDirectory: string;
+}) => string;
+export declare const renderSystemdUnit: ({ serviceName, launcherPath, root }: Omit<ServiceUnitDefinition, "serviceFilePath" | "serviceFileContents"> & {
+    launcherPath: string;
+    root: string;
+}) => string;
+export declare const createDarwinServiceDefinition: ({ installId, scope, launcherPath, root, metadataDirectory, homeDir }: ServiceUnitInput) => ServiceUnitDefinition;
+export declare const createLinuxServiceDefinition: ({ installId, scope, launcherPath, root, homeDir }: ServiceUnitInput) => ServiceUnitDefinition;
+export declare const getDarwinInstallCommands: (definition: ServiceUnitDefinition, scope: ServiceScope, userId?: number) => ServiceCommand[];
+export declare const getDarwinRestartCommands: (definition: ServiceUnitDefinition, scope: ServiceScope, userId?: number) => ServiceCommand[];
+export declare const getDarwinUninstallCommands: (definition: ServiceUnitDefinition, scope: ServiceScope, userId?: number) => ServiceCommand[];
+export declare const getLinuxInstallCommands: (definition: ServiceUnitDefinition, scope: ServiceScope) => ServiceCommand[];
+export declare const getLinuxRestartCommands: (definition: ServiceUnitDefinition, scope: ServiceScope) => ServiceCommand[];
+export declare const getLinuxUninstallCommands: (definition: ServiceUnitDefinition, scope: ServiceScope) => ServiceCommand[];

package/dist/service-adapters.js

@@ -0,0 +1,185 @@
+import os from 'node:os';
+import { join } from 'node:path';
+const renderLaunchdArray = (values) => values.map(value => `    <string>${escapeXml(value)}</string>`).join('\n');
+const escapeXml = (value) => value
+    .replaceAll('&', '&amp;')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&apos;');
+const getCurrentUserId = () => (typeof process.getuid === 'function' ? process.getuid() : 0);
+const getLaunchctlDomain = (scope, userId = getCurrentUserId()) => scope === 'system' ? 'system' : `gui/${userId}`;
+const getSystemdPrefix = (scope) => scope === 'system' ? [] : ['--user'];
+const quoteSystemdPathValue = (value) => `"${value
+    .replaceAll('\\', '\\\\')
+    .replaceAll('"', '\\"')
+    .replaceAll('%', '%%')}"`;
+const quoteSystemdExecValue = (value) => quoteSystemdPathValue(value).replaceAll('$', '$$$$');
+export const resolveServicePlatform = (platform = process.platform) => {
+    if (platform === 'darwin' || platform === 'linux') {
+        return platform;
+    }
+    throw new Error(`Unsupported service platform "${platform}".`);
+};
+export const getDarwinServiceName = (installId) => `io.codori.server.${installId}`;
+export const getLinuxServiceName = (installId) => `codori-${installId}.service`;
+export const renderLaunchdPlist = ({ serviceName, launcherPath, root, metadataDirectory }) => [
+    '<?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>${escapeXml(serviceName)}</string>`,
+    '  <key>ProgramArguments</key>',
+    '  <array>',
+    renderLaunchdArray([launcherPath]),
+    '  </array>',
+    '  <key>RunAtLoad</key>',
+    '  <true/>',
+    '  <key>KeepAlive</key>',
+    '  <true/>',
+    '  <key>WorkingDirectory</key>',
+    `  <string>${escapeXml(root)}</string>`,
+    '  <key>StandardOutPath</key>',
+    `  <string>${escapeXml(join(metadataDirectory, 'service.log'))}</string>`,
+    '  <key>StandardErrorPath</key>',
+    `  <string>${escapeXml(join(metadataDirectory, 'service.error.log'))}</string>`,
+    '</dict>',
+    '</plist>'
+].join('\n');
+export const renderSystemdUnit = ({ serviceName, launcherPath, root }) => [
+    '[Unit]',
+    `Description=Codori service (${serviceName})`,
+    'After=network.target',
+    '',
+    '[Service]',
+    'Type=simple',
+    `WorkingDirectory=${quoteSystemdPathValue(root)}`,
+    `ExecStart=${quoteSystemdExecValue(launcherPath)}`,
+    'Restart=always',
+    'RestartSec=5',
+    '',
+    '[Install]',
+    'WantedBy=default.target'
+].join('\n');
+export const createDarwinServiceDefinition = ({ installId, scope, launcherPath, root, metadataDirectory, homeDir = os.homedir() }) => {
+    const serviceName = getDarwinServiceName(installId);
+    const serviceFilePath = scope === 'system'
+        ? join('/Library/LaunchDaemons', `${serviceName}.plist`)
+        : join(homeDir, 'Library', 'LaunchAgents', `${serviceName}.plist`);
+    return {
+        serviceName,
+        serviceFilePath,
+        serviceFileContents: renderLaunchdPlist({
+            serviceName,
+            launcherPath,
+            root,
+            metadataDirectory
+        })
+    };
+};
+export const createLinuxServiceDefinition = ({ installId, scope, launcherPath, root, homeDir = os.homedir() }) => {
+    const serviceName = getLinuxServiceName(installId);
+    const serviceFilePath = scope === 'system'
+        ? join('/etc/systemd/system', serviceName)
+        : join(homeDir, '.config', 'systemd', 'user', serviceName);
+    return {
+        serviceName,
+        serviceFilePath,
+        serviceFileContents: renderSystemdUnit({
+            serviceName,
+            launcherPath,
+            root
+        })
+    };
+};
+export const getDarwinInstallCommands = (definition, scope, userId = getCurrentUserId()) => {
+    const domain = getLaunchctlDomain(scope, userId);
+    return [
+        {
+            command: 'launchctl',
+            args: ['bootout', domain, definition.serviceFilePath]
+        },
+        {
+            command: 'launchctl',
+            args: ['bootstrap', domain, definition.serviceFilePath]
+        },
+        {
+            command: 'launchctl',
+            args: ['enable', `${domain}/${definition.serviceName}`]
+        },
+        {
+            command: 'launchctl',
+            args: ['kickstart', '-k', `${domain}/${definition.serviceName}`]
+        }
+    ];
+};
+export const getDarwinRestartCommands = (definition, scope, userId = getCurrentUserId()) => {
+    const domain = getLaunchctlDomain(scope, userId);
+    return [
+        {
+            command: 'launchctl',
+            args: ['bootout', domain, definition.serviceFilePath]
+        },
+        {
+            command: 'launchctl',
+            args: ['bootstrap', domain, definition.serviceFilePath]
+        },
+        {
+            command: 'launchctl',
+            args: ['kickstart', '-k', `${domain}/${definition.serviceName}`]
+        }
+    ];
+};
+export const getDarwinUninstallCommands = (definition, scope, userId = getCurrentUserId()) => {
+    const domain = getLaunchctlDomain(scope, userId);
+    return [
+        {
+            command: 'launchctl',
+            args: ['bootout', domain, definition.serviceFilePath]
+        },
+        {
+            command: 'launchctl',
+            args: ['disable', `${domain}/${definition.serviceName}`]
+        }
+    ];
+};
+export const getLinuxInstallCommands = (definition, scope) => {
+    const prefix = getSystemdPrefix(scope);
+    return [
+        {
+            command: 'systemctl',
+            args: [...prefix, 'daemon-reload']
+        },
+        {
+            command: 'systemctl',
+            args: [...prefix, 'enable', '--now', definition.serviceName]
+        }
+    ];
+};
+export const getLinuxRestartCommands = (definition, scope) => {
+    const prefix = getSystemdPrefix(scope);
+    return [
+        {
+            command: 'systemctl',
+            args: [...prefix, 'daemon-reload']
+        },
+        {
+            command: 'systemctl',
+            args: [...prefix, 'restart', definition.serviceName]
+        }
+    ];
+};
+export const getLinuxUninstallCommands = (definition, scope) => {
+    const prefix = getSystemdPrefix(scope);
+    return [
+        {
+            command: 'systemctl',
+            args: [...prefix, 'disable', '--now', definition.serviceName]
+        },
+        {
+            command: 'systemctl',
+            args: [...prefix, 'daemon-reload']
+        }
+    ];
+};

package/dist/service-update.d.ts

@@ -0,0 +1,26 @@
+export type ServiceUpdateStatus = {
+    enabled: boolean;
+    updateAvailable: boolean;
+    updating: boolean;
+    installedVersion: string | null;
+    latestVersion: string | null;
+};
+export type ServiceUpdateController = {
+    getStatus: () => Promise<ServiceUpdateStatus>;
+    requestUpdate: () => Promise<ServiceUpdateStatus>;
+};
+export type ServiceUpdateControllerOptions = {
+    root: string;
+    env?: NodeJS.ProcessEnv;
+    homeDir?: string;
+    now?: () => number;
+    npxPath?: string;
+    fetchImpl?: typeof fetch;
+    cacheTtlMs?: number;
+    registryTimeoutMs?: number;
+    spawnUpdateProcess?: (command: string, args: string[], options: {
+        env: NodeJS.ProcessEnv;
+    }) => Promise<void>;
+};
+export declare const comparePackageVersions: (left: string, right: string) => number;
+export declare const createServiceUpdateController: (options: ServiceUpdateControllerOptions) => ServiceUpdateController;

package/dist/service-update.js

@@ -0,0 +1,196 @@
+import { spawn } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import os from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { CodoriError } from './errors.js';
+import { CODORI_SERVICE_INSTALL_ID_ENV, CODORI_SERVICE_MANAGED_ENV, CODORI_SERVICE_SCOPE_ENV, getServiceMetadataDirectory } from './service.js';
+const PACKAGE_MANIFEST_PATH = fileURLToPath(new URL('../package.json', import.meta.url));
+const UPDATE_CHECK_TTL_MS = 5 * 60 * 1_000;
+const REGISTRY_TIMEOUT_MS = 3_000;
+const shellEscape = (value) => `'${value.replaceAll("'", "'\"'\"'")}'`;
+const readPackageManifest = () => {
+    const parsed = JSON.parse(readFileSync(PACKAGE_MANIFEST_PATH, 'utf8'));
+    if (typeof parsed !== 'object'
+        || parsed === null
+        || typeof parsed.name !== 'string'
+        || typeof parsed.version !== 'string') {
+        throw new Error(`Invalid package manifest at ${PACKAGE_MANIFEST_PATH}.`);
+    }
+    return {
+        name: parsed.name,
+        version: parsed.version
+    };
+};
+const CURRENT_PACKAGE = readPackageManifest();
+const DISABLED_STATUS = {
+    enabled: false,
+    updateAvailable: false,
+    updating: false,
+    installedVersion: null,
+    latestVersion: null
+};
+const coerceVersionPart = (value) => {
+    if (/^\d+$/u.test(value)) {
+        return Number.parseInt(value, 10);
+    }
+    return value;
+};
+export const comparePackageVersions = (left, right) => {
+    const maxLength = Math.max(left.split('.').length, right.split('.').length);
+    const leftParts = left.split('.').map(coerceVersionPart);
+    const rightParts = right.split('.').map(coerceVersionPart);
+    for (let index = 0; index < maxLength; index += 1) {
+        const leftPart = leftParts[index] ?? 0;
+        const rightPart = rightParts[index] ?? 0;
+        if (leftPart === rightPart) {
+            continue;
+        }
+        if (typeof leftPart === 'number' && typeof rightPart === 'number') {
+            return leftPart > rightPart ? 1 : -1;
+        }
+        return String(leftPart).localeCompare(String(rightPart), undefined, { numeric: true });
+    }
+    return 0;
+};
+const resolveServiceRuntimeContext = (env) => {
+    if (env[CODORI_SERVICE_MANAGED_ENV] !== '1') {
+        return null;
+    }
+    const installId = env[CODORI_SERVICE_INSTALL_ID_ENV]?.trim();
+    const scope = env[CODORI_SERVICE_SCOPE_ENV]?.trim();
+    if (!installId || (scope !== 'user' && scope !== 'system')) {
+        return null;
+    }
+    return {
+        installId,
+        scope
+    };
+};
+const fetchLatestPackageVersion = async (fetchImpl, registryTimeoutMs) => {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => {
+        controller.abort();
+    }, registryTimeoutMs);
+    let response;
+    try {
+        response = await fetchImpl(`https://registry.npmjs.org/${encodeURIComponent(CURRENT_PACKAGE.name)}/latest`, {
+            headers: {
+                accept: 'application/json'
+            },
+            signal: controller.signal
+        });
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+    if (!response.ok) {
+        throw new Error(`npm registry request failed with status ${response.status}.`);
+    }
+    const payload = await response.json();
+    if (typeof payload !== 'object' || payload === null || typeof payload.version !== 'string') {
+        throw new Error('npm registry response did not include a valid version.');
+    }
+    return payload.version;
+};
+const createUpdateScript = (runtime, options) => {
+    const metadataDirectory = getServiceMetadataDirectory(runtime.installId, options.homeDir);
+    const updateLogPath = join(metadataDirectory, 'update.log');
+    return [
+        'sleep 1',
+        `${shellEscape(options.npxPath)} --yes ${shellEscape(`${CURRENT_PACKAGE.name}@latest`)} restart-service --root ${shellEscape(options.root)} --scope ${shellEscape(runtime.scope)} --yes >> ${shellEscape(updateLogPath)} 2>&1`
+    ].join('; ');
+};
+const defaultSpawnUpdateProcess = async (command, args, options) => {
+    await new Promise((resolvePromise, reject) => {
+        const child = spawn(command, args, {
+            detached: true,
+            env: options.env,
+            stdio: 'ignore',
+            windowsHide: true
+        });
+        child.once('error', reject);
+        child.once('spawn', () => {
+            child.unref();
+            resolvePromise();
+        });
+    });
+};
+export const createServiceUpdateController = (options) => {
+    const env = options.env ?? process.env;
+    const homeDir = options.homeDir ?? os.homedir();
+    const npxPath = options.npxPath ?? join(dirname(process.execPath), 'npx');
+    const now = options.now ?? (() => Date.now());
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const cacheTtlMs = options.cacheTtlMs ?? UPDATE_CHECK_TTL_MS;
+    const registryTimeoutMs = options.registryTimeoutMs ?? REGISTRY_TIMEOUT_MS;
+    const spawnUpdateProcess = options.spawnUpdateProcess ?? defaultSpawnUpdateProcess;
+    const runtime = resolveServiceRuntimeContext(env);
+    let updating = false;
+    let cachedStatus = null;
+    let cachedAt = 0;
+    let pendingStatus = null;
+    const resolveStatus = async () => {
+        if (!runtime) {
+            return DISABLED_STATUS;
+        }
+        if (pendingStatus) {
+            return pendingStatus;
+        }
+        if (cachedStatus && now() - cachedAt < cacheTtlMs) {
+            return {
+                ...cachedStatus,
+                updating
+            };
+        }
+        pendingStatus = (async () => {
+            let latestVersion = cachedStatus?.latestVersion ?? null;
+            try {
+                latestVersion = await fetchLatestPackageVersion(fetchImpl, registryTimeoutMs);
+            }
+            catch {
+                latestVersion = cachedStatus?.latestVersion ?? null;
+            }
+            const nextStatus = {
+                enabled: true,
+                updateAvailable: latestVersion !== null && comparePackageVersions(latestVersion, CURRENT_PACKAGE.version) > 0,
+                updating,
+                installedVersion: CURRENT_PACKAGE.version,
+                latestVersion
+            };
+            cachedStatus = nextStatus;
+            cachedAt = now();
+            pendingStatus = null;
+            return nextStatus;
+        })();
+        return pendingStatus;
+    };
+    return {
+        getStatus: async () => await resolveStatus(),
+        requestUpdate: async () => {
+            if (!runtime) {
+                throw new CodoriError('SERVICE_UPDATE_UNAVAILABLE', 'Self-update is only available while Codori is running as a registered service.');
+            }
+            if (updating) {
+                throw new CodoriError('SERVICE_UPDATE_IN_PROGRESS', 'Codori is already applying a service update.');
+            }
+            const status = await resolveStatus();
+            if (!status.updateAvailable) {
+                throw new CodoriError('SERVICE_UPDATE_UNAVAILABLE', 'No newer @codori/server package is currently available.');
+            }
+            const script = createUpdateScript(runtime, {
+                root: options.root,
+                npxPath,
+                homeDir
+            });
+            await spawnUpdateProcess('/bin/sh', ['-lc', script], { env });
+            updating = true;
+            cachedStatus = {
+                ...status,
+                updating: true
+            };
+            cachedAt = now();
+            return cachedStatus;
+        }
+    };
+};

package/dist/service.d.ts

@@ -0,0 +1,86 @@
+export type ServiceScope = 'user' | 'system';
+export type ServicePlatform = 'darwin' | 'linux';
+export type ServiceInstallMetadata = {
+    installId: string;
+    root: string;
+    host: string;
+    port: number;
+    scope: ServiceScope;
+    platform: ServicePlatform;
+    serviceName: string;
+    serviceFilePath: string;
+    launcherPath: string;
+    installedAt: string;
+};
+export type RootPromptDefault = {
+    value: string | null;
+    reason: 'git' | 'workspace-marker' | 'nested-git-projects' | 'none';
+    shouldConfirm: boolean;
+};
+export type HostPromptDefault = {
+    value: string;
+    source: 'explicit' | 'tailscale' | 'wildcard';
+    warning: string | null;
+};
+export type CommandResult = {
+    exitCode: number | null;
+    stdout: string;
+    stderr: string;
+};
+export type CommandRunner = (command: string, args: string[]) => Promise<CommandResult>;
+export type LauncherScriptInput = {
+    installId: string;
+    root: string;
+    host: string;
+    port: number;
+    scope: ServiceScope;
+    nodePath: string;
+    npxPath: string;
+};
+export type ServicePrompt = {
+    input: (message: string, defaultValue?: string) => Promise<string>;
+    confirm: (message: string, defaultValue: boolean) => Promise<boolean>;
+    close: () => Promise<void> | void;
+};
+export type ServiceCommandName = 'install-service' | 'setup-service' | 'restart-service' | 'uninstall-service';
+export type ServiceCommandOptions = {
+    root?: string;
+    host?: string;
+    port?: string | number;
+    scope?: string;
+    yes?: boolean;
+};
+export type ServiceCommandDependencies = {
+    cwd?: string;
+    homeDir?: string;
+    platform?: NodeJS.Platform;
+    nodePath?: string;
+    npxPath?: string;
+    stdin?: NodeJS.ReadableStream;
+    stdout?: NodeJS.WritableStream;
+    runCommand?: CommandRunner;
+    prompt?: ServicePrompt;
+    now?: () => Date;
+};
+export type ServiceOperationResult = {
+    action: 'install' | 'restart' | 'uninstall';
+    metadata: ServiceInstallMetadata;
+};
+export declare const CODORI_SERVICE_MANAGED_ENV = "CODORI_SERVICE_MANAGED";
+export declare const CODORI_SERVICE_INSTALL_ID_ENV = "CODORI_SERVICE_INSTALL_ID";
+export declare const CODORI_SERVICE_SCOPE_ENV = "CODORI_SERVICE_SCOPE";
+export declare const toServiceInstallId: (root: string) => string;
+export declare const getServiceMetadataDirectory: (installId: string, homeDir?: string) => string;
+export declare const getServiceMetadataPath: (installId: string, homeDir?: string) => string;
+export declare const getServiceLauncherPath: (installId: string, homeDir?: string) => string;
+export declare const detectRootPromptDefault: (cwd: string) => RootPromptDefault;
+export declare const resolveServiceScope: (value: string | undefined) => ServiceScope;
+export declare const parseServicePort: (value: string | number | undefined) => number | undefined;
+export declare const resolveDefaultServicePort: (value: number | undefined) => number;
+export declare const getWildcardHostWarning: () => string;
+export declare const detectTailscaleIpv4: (runCommand?: CommandRunner) => Promise<string | null>;
+export declare const resolveHostPromptDefault: (explicitHost: string | undefined, runCommand?: CommandRunner) => Promise<HostPromptDefault>;
+export declare const buildLauncherScript: ({ installId, root, host, port, scope, nodePath, npxPath }: LauncherScriptInput) => string;
+export declare const installService: (options?: ServiceCommandOptions, dependencies?: ServiceCommandDependencies) => Promise<ServiceOperationResult>;
+export declare const restartService: (options?: ServiceCommandOptions, dependencies?: ServiceCommandDependencies) => Promise<ServiceOperationResult>;
+export declare const uninstallService: (options?: ServiceCommandOptions, dependencies?: ServiceCommandDependencies) => Promise<ServiceOperationResult>;