@chalksurf/cli 0.1.0 → 0.2.1

package/dist/lib/config-store.js

@@ -5,7 +5,11 @@ import { CliCommandError } from './cli-error.js';
 export const chalksurfBaseUrlEnvVar = 'CHALKSURF_BASE_URL';
 export const chalksurfTokenEnvVar = 'CHALKSURF_TOKEN';
 export const chalksurfOrganizationIdEnvVar = 'CHALKSURF_ORGANIZATION_ID';
+export const chalksurfProfileEnvVar = 'CHALKSURF_PROFILE';
 export const chalksurfConfigPathEnvVar = 'CHALKSURF_CONFIG_PATH';
+export const cliConfigSchemaVersion = 2;
+export const implicitDefaultProfileName = 'default';
+const profileNamePattern = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
 const normalizeOptionalString = (value) => {
     const trimmedValue = value?.trim();
     return trimmedValue ? trimmedValue : undefined;
@@ -14,13 +18,91 @@ const normalizeStoredBaseUrl = (value) => {
     const normalizedValue = normalizeOptionalString(value);
     return normalizedValue?.replace(/\/+$/, '') || undefined;
 };
-const sanitizeConfig = (config) => {
+const isRecord = (value) => {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+};
+export const assertValidProfileName = (profileName) => {
+    if (!profileNamePattern.test(profileName)) {
+        throw new CliCommandError(`Invalid profile "${profileName}". Profile names must start with a letter or number and contain only letters, numbers, ".", "_", or "-".`, 2);
+    }
+};
+const normalizeProfileName = (value) => {
+    const profileName = normalizeOptionalString(value);
+    if (!profileName) {
+        return undefined;
+    }
+    assertValidProfileName(profileName);
+    return profileName;
+};
+const sanitizeProfileConfig = (config) => {
     return Object.fromEntries(Object.entries({
         token: normalizeOptionalString(config.token),
         baseUrl: normalizeStoredBaseUrl(config.baseUrl),
         organizationId: normalizeOptionalString(config.organizationId),
     }).filter(([, value]) => value !== undefined));
 };
+const hasProfileConfigValues = (config) => {
+    return Boolean(config.baseUrl || config.token || config.organizationId);
+};
+const readProfileConfig = (value) => {
+    if (!isRecord(value)) {
+        return {};
+    }
+    return sanitizeProfileConfig({
+        baseUrl: typeof value.baseUrl === 'string' ? value.baseUrl : undefined,
+        organizationId: typeof value.organizationId === 'string' ? value.organizationId : undefined,
+        token: typeof value.token === 'string' ? value.token : undefined,
+    });
+};
+const sanitizeRootConfig = (config) => {
+    const profiles = Object.fromEntries(Object.entries(config.profiles)
+        .map(([profileName, profileConfig]) => {
+        const normalizedProfileName = normalizeProfileName(profileName);
+        const sanitizedProfileConfig = sanitizeProfileConfig(profileConfig);
+        return normalizedProfileName && hasProfileConfigValues(sanitizedProfileConfig)
+            ? [normalizedProfileName, sanitizedProfileConfig]
+            : null;
+    })
+        .filter((entry) => entry !== null));
+    const defaultProfile = normalizeProfileName(config.defaultProfile);
+    return {
+        schemaVersion: cliConfigSchemaVersion,
+        ...(defaultProfile && profiles[defaultProfile] ? { defaultProfile } : {}),
+        profiles,
+    };
+};
+const readRootConfig = (value) => {
+    if (!isRecord(value)) {
+        return { schemaVersion: cliConfigSchemaVersion, profiles: {} };
+    }
+    if (isRecord(value.profiles)) {
+        const profiles = Object.fromEntries(Object.entries(value.profiles)
+            .map(([profileName, profileConfig]) => {
+            const sanitizedProfileConfig = readProfileConfig(profileConfig);
+            return hasProfileConfigValues(sanitizedProfileConfig)
+                ? [profileName, sanitizedProfileConfig]
+                : null;
+        })
+            .filter((entry) => entry !== null));
+        return sanitizeRootConfig({
+            schemaVersion: cliConfigSchemaVersion,
+            defaultProfile: typeof value.defaultProfile === 'string' ? value.defaultProfile : undefined,
+            profiles,
+        });
+    }
+    const legacyProfile = readProfileConfig(value);
+    if (!hasProfileConfigValues(legacyProfile)) {
+        return { schemaVersion: cliConfigSchemaVersion, profiles: {} };
+    }
+    return {
+        schemaVersion: cliConfigSchemaVersion,
+        defaultProfile: implicitDefaultProfileName,
+        profiles: {
+            [implicitDefaultProfileName]: legacyProfile,
+        },
+    };
+};
+const rootConfigHasProfiles = (config) => Object.keys(config.profiles).length > 0;
 const getDefaultConfigPath = ({ env, platform, homeDirectory, }) => {
     const explicitConfigPath = normalizeOptionalString(env[chalksurfConfigPathEnvVar]);
     if (explicitConfigPath) {
@@ -73,6 +155,24 @@ export const resolveToken = ({ env, config }) => {
     }
     return { source: 'none' };
 };
+export const resolveProfile = ({ flagValue, env, config, }) => {
+    const flagProfileName = normalizeProfileName(flagValue);
+    if (flagProfileName) {
+        return { profileName: flagProfileName, profileSource: 'flag' };
+    }
+    const envProfileName = normalizeProfileName(env[chalksurfProfileEnvVar]);
+    if (envProfileName) {
+        return { profileName: envProfileName, profileSource: 'env' };
+    }
+    const defaultProfile = normalizeProfileName(config.defaultProfile);
+    if (defaultProfile) {
+        return { profileName: defaultProfile, profileSource: 'config' };
+    }
+    if (!rootConfigHasProfiles(config)) {
+        return { profileName: implicitDefaultProfileName, profileSource: 'implicit-default' };
+    }
+    throw new CliCommandError(`No active ChalkSurf profile selected. Pass --profile, set ${chalksurfProfileEnvVar}, or run "chalksurf profile use <profile>".`, 2);
+};
 export const resolveOrganization = ({ flagValue, env, config, profile, }) => {
     const flagOrganizationId = normalizeOptionalString(flagValue);
     if (flagOrganizationId) {
@@ -134,14 +234,23 @@ export const resolveOrganization = ({ flagValue, env, config, profile, }) => {
 export const createConfigStore = ({ configPath, env = process.env, platform = process.platform, homeDirectory = homedir(), fs = { chmod, mkdir, readFile, rm, writeFile }, } = {}) => {
     const resolvedConfigPath = configPath || getDefaultConfigPath({ env, platform, homeDirectory });
     const load = async () => {
+        const rootConfig = await loadRoot();
+        const resolvedProfile = resolveProfile({ env, config: rootConfig });
+        const profileConfig = rootConfig.profiles[resolvedProfile.profileName] ?? {};
+        return {
+            ...profileConfig,
+            ...resolvedProfile,
+        };
+    };
+    const loadRoot = async () => {
         try {
             const configContents = await fs.readFile(resolvedConfigPath, 'utf8');
             const parsedConfig = JSON.parse(configContents);
-            return sanitizeConfig(parsedConfig);
+            return readRootConfig(parsedConfig);
         }
         catch (error) {
             if (error.code === 'ENOENT') {
-                return {};
+                return { schemaVersion: cliConfigSchemaVersion, profiles: {} };
             }
             if (error instanceof SyntaxError) {
                 throw new CliCommandError(`Failed to parse CLI config at ${resolvedConfigPath}.`, 2);
@@ -149,9 +258,18 @@ export const createConfigStore = ({ configPath, env = process.env, platform = pr
             throw error;
         }
     };
-    const save = async (config) => {
-        const sanitizedConfig = sanitizeConfig(config);
-        if (Object.keys(sanitizedConfig).length === 0) {
+    const loadProfile = async ({ profileName } = {}) => {
+        const rootConfig = await loadRoot();
+        const resolvedProfile = resolveProfile({ flagValue: profileName, env, config: rootConfig });
+        const profileConfig = rootConfig.profiles[resolvedProfile.profileName] ?? {};
+        return {
+            ...profileConfig,
+            ...resolvedProfile,
+        };
+    };
+    const saveRoot = async (config) => {
+        const sanitizedConfig = sanitizeRootConfig(config);
+        if (!rootConfigHasProfiles(sanitizedConfig)) {
             await fs.rm(resolvedConfigPath, { force: true });
             return sanitizedConfig;
         }
@@ -162,15 +280,75 @@ export const createConfigStore = ({ configPath, env = process.env, platform = pr
         await fs.chmod(resolvedConfigPath, 0o600);
         return sanitizedConfig;
     };
-    const update = async (updater) => {
-        const currentConfig = await load();
-        const nextConfig = await updater(currentConfig);
-        return await save(nextConfig);
+    const save = async (config) => {
+        const rootConfig = await loadRoot();
+        const nextProfileConfig = sanitizeProfileConfig(config);
+        const nextRootConfig = {
+            ...rootConfig,
+            profiles: {
+                ...rootConfig.profiles,
+            },
+        };
+        if (hasProfileConfigValues(nextProfileConfig)) {
+            nextRootConfig.profiles[config.profileName] = nextProfileConfig;
+        }
+        else {
+            delete nextRootConfig.profiles[config.profileName];
+        }
+        if (config.profileSource === 'implicit-default' && hasProfileConfigValues(nextProfileConfig)) {
+            nextRootConfig.defaultProfile = config.profileName;
+        }
+        return await saveRoot(nextRootConfig);
+    };
+    const update = async ({ profileName }, updater) => {
+        const currentConfig = await loadProfile({ profileName });
+        const nextProfileConfig = await updater(currentConfig);
+        return await save({
+            ...nextProfileConfig,
+            profileName: currentConfig.profileName,
+            profileSource: currentConfig.profileSource,
+        });
+    };
+    const setDefaultProfile = async (profileName) => {
+        const normalizedProfileName = normalizeProfileName(profileName);
+        if (!normalizedProfileName) {
+            throw new CliCommandError('Profile name is required.', 2);
+        }
+        const rootConfig = await loadRoot();
+        if (!rootConfig.profiles[normalizedProfileName]) {
+            throw new CliCommandError(`Profile "${normalizedProfileName}" does not exist. Run "chalksurf auth login --profile ${normalizedProfileName} --base-url <url>" first.`, 2);
+        }
+        return await saveRoot({
+            ...rootConfig,
+            defaultProfile: normalizedProfileName,
+        });
+    };
+    const deleteProfile = async (profileName) => {
+        const normalizedProfileName = normalizeProfileName(profileName);
+        if (!normalizedProfileName) {
+            throw new CliCommandError('Profile name is required.', 2);
+        }
+        const rootConfig = await loadRoot();
+        if (!rootConfig.profiles[normalizedProfileName]) {
+            throw new CliCommandError(`Profile "${normalizedProfileName}" does not exist.`, 2);
+        }
+        const profiles = { ...rootConfig.profiles };
+        delete profiles[normalizedProfileName];
+        return await saveRoot({
+            schemaVersion: cliConfigSchemaVersion,
+            ...(rootConfig.defaultProfile === normalizedProfileName ? {} : { defaultProfile: rootConfig.defaultProfile }),
+            profiles,
+        });
     };
     return {
         path: resolvedConfigPath,
         load,
+        loadProfile,
+        loadRoot,
         save,
+        saveRoot,
         update,
+        setDefaultProfile,
+        deleteProfile,
     };
 };

package/dist/lib/import-files.js

@@ -0,0 +1,120 @@
+import { openAsBlob } from 'node:fs';
+import { stat } from 'node:fs/promises';
+import { extname, resolve } from 'node:path';
+import { CliCommandError } from './cli-error.js';
+const mimeTypesByExtension = {
+    '.avif': 'image/avif',
+    '.doc': 'application/msword',
+    '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    '.gif': 'image/gif',
+    '.htm': 'text/html',
+    '.html': 'text/html',
+    '.jpeg': 'image/jpeg',
+    '.jpg': 'image/jpeg',
+    '.md': 'text/markdown',
+    '.pdf': 'application/pdf',
+    '.png': 'image/png',
+    '.svg': 'image/svg+xml',
+    '.tex': 'text/plain',
+    '.tif': 'image/tiff',
+    '.tiff': 'image/tiff',
+    '.txt': 'text/plain',
+    '.webp': 'image/webp',
+};
+const guessMimeType = (fileName) => {
+    return mimeTypesByExtension[extname(fileName).toLowerCase()] ?? 'application/octet-stream';
+};
+const isHttpUrl = (value) => {
+    try {
+        const parsedUrl = new URL(value);
+        return ['http:', 'https:'].includes(parsedUrl.protocol);
+    }
+    catch {
+        return false;
+    }
+};
+export const buildFileImportFormData = async (resolvedSources) => {
+    const formData = new FormData();
+    await Promise.all(resolvedSources.map(async (resolvedSource, index) => {
+        const mimeType = resolvedSource.mimeType ?? guessMimeType(resolvedSource.fileName);
+        const fileBlob = await openAsBlob(resolvedSource.filePath, { type: mimeType });
+        const file = new File([fileBlob], resolvedSource.fileName, { type: mimeType });
+        formData.set(`file-${index}`, file);
+        formData.set(`path-${index}`, resolvedSource.relativePath);
+    }));
+    return formData;
+};
+export const buildFileImportCommandSources = async ({ cwd, loadManifest, manifestPath, rawSources, relativePath, stdin, wait, }) => {
+    if (manifestPath && rawSources.length > 0) {
+        throw new CliCommandError('Pass positional sources or --manifest, not both.', 2);
+    }
+    if (manifestPath && relativePath) {
+        throw new CliCommandError('--relative-path can only be used with a single positional source.', 2);
+    }
+    if (manifestPath) {
+        const manifest = await loadManifest({
+            cwd,
+            manifestPath,
+            stdin,
+        });
+        const { organizationId, sources, wait: manifestWait, ...manifestExtras } = manifest;
+        return {
+            organizationId,
+            sources,
+            wait: wait || manifestWait === true,
+            ...manifestExtras,
+        };
+    }
+    if (rawSources.length === 0) {
+        throw new CliCommandError('At least one source or --manifest is required.', 2);
+    }
+    if (relativePath && rawSources.length !== 1) {
+        throw new CliCommandError('--relative-path can only be used with a single positional source.', 2);
+    }
+    const sources = [];
+    for (const rawSource of rawSources) {
+        if (isHttpUrl(rawSource)) {
+            sources.push({
+                kind: 'url',
+                url: rawSource,
+                relativePath,
+            });
+            continue;
+        }
+        try {
+            const pathStats = await stat(resolve(cwd, rawSource));
+            if (pathStats.isDirectory()) {
+                if (relativePath) {
+                    throw new CliCommandError('--relative-path cannot be used with directory sources.', 2);
+                }
+                sources.push({
+                    kind: 'directory',
+                    path: rawSource,
+                });
+                continue;
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                throw error;
+            }
+        }
+        sources.push({
+            kind: 'local',
+            path: rawSource,
+            relativePath,
+        });
+    }
+    return {
+        organizationId: undefined,
+        sources,
+        wait: wait === true,
+    };
+};
+export const normalizeWaitTimeoutMs = (timeoutMs) => {
+    const normalizedTimeoutMs = timeoutMs ?? 300000;
+    if (!Number.isFinite(normalizedTimeoutMs) || normalizedTimeoutMs <= 0) {
+        throw new CliCommandError('--timeout-ms must be a positive number.', 2);
+    }
+    return normalizedTimeoutMs;
+};

package/dist/lib/import-output.js

@@ -0,0 +1,67 @@
+export const buildCliImportSources = ({ resolvedSources, getExtra, }) => {
+    return resolvedSources.map((resolvedSource, sourceIndex) => ({
+        sourceIndex,
+        sourceInputIndex: resolvedSource.sourceInputIndex,
+        sourceId: resolvedSource.sourceInput.sourceId ?? null,
+        kind: resolvedSource.kind,
+        input: resolvedSource.input,
+        fileName: resolvedSource.fileName,
+        relativePath: resolvedSource.relativePath,
+        ...(getExtra ? getExtra(resolvedSource) : {}),
+    }));
+};
+export const summarizeCliImportJobs = ({ jobs, sourceCount, sourceInputCount, timedOut, }) => {
+    const summary = {
+        sourceCount,
+        sourceInputCount,
+        jobCount: jobs.length,
+        queued: 0,
+        pending: 0,
+        inProgress: 0,
+        completed: 0,
+        failed: 0,
+        timedOut,
+    };
+    for (const job of jobs) {
+        if (job.status === 'queued') {
+            summary.queued += 1;
+            continue;
+        }
+        if (job.status === 'pending') {
+            summary.pending += 1;
+            continue;
+        }
+        if (job.status === 'in_progress') {
+            summary.inProgress += 1;
+            continue;
+        }
+        if (job.status === 'completed') {
+            summary.completed += 1;
+            continue;
+        }
+        summary.failed += 1;
+    }
+    return summary;
+};
+export const formatCliImportSummary = (summary) => {
+    const parts = [];
+    if (summary.queued > 0) {
+        parts.push(`${summary.queued} queued`);
+    }
+    if (summary.pending > 0) {
+        parts.push(`${summary.pending} pending`);
+    }
+    if (summary.inProgress > 0) {
+        parts.push(`${summary.inProgress} in progress`);
+    }
+    if (summary.completed > 0) {
+        parts.push(`${summary.completed} completed`);
+    }
+    if (summary.failed > 0) {
+        parts.push(`${summary.failed} failed`);
+    }
+    if (summary.timedOut) {
+        parts.push('timed out');
+    }
+    return `Summary: ${parts.join(', ') || '0 jobs'}.`;
+};