@ayushporwal/coja 0.0.1

package/dist/codex/oauth.js

@@ -0,0 +1,217 @@
+import { createHash, randomBytes, randomUUID } from 'node:crypto';
+import { createServer } from 'node:http';
+import { CodexError, redact } from './errors.js';
+import { authorizeUrl, redirectUri } from './protocol.js';
+export const challengeFor = (verifier) => createHash('sha256').update(verifier, 'utf8').digest('base64url');
+export async function generatePkce() {
+    const verifier = randomBytes(64).toString('base64url');
+    return { verifier, challenge: challengeFor(verifier) };
+}
+export const generateState = () => randomBytes(32).toString('base64url');
+/** Unverified JWT payload decode — metadata only, never an auth check. */
+export function decodeJwtPayload(token) {
+    const parts = token.split('.');
+    const payload = parts.length === 3 ? parts[1] : undefined;
+    if (payload === undefined)
+        return undefined;
+    try {
+        return JSON.parse(Buffer.from(payload, 'base64url').toString('utf8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+function authClaims(payload) {
+    const claims = payload?.['https://api.openai.com/auth'];
+    return typeof claims === 'object' && claims !== null ? claims : {};
+}
+/**
+ * Account id and plan from `id_token`, falling back to the access token.
+ * Values are unverified metadata: they route requests and label the UI, and
+ * nothing authorizes on them.
+ */
+export function extractMetadata(tokens) {
+    for (const token of [tokens.id_token, tokens.access_token]) {
+        if (!token)
+            continue;
+        const payload = decodeJwtPayload(token);
+        const claims = authClaims(payload);
+        const accountId = claims.chatgpt_account_id ??
+            (typeof payload?.chatgpt_account_id === 'string' ? payload.chatgpt_account_id : undefined);
+        if (accountId) {
+            return {
+                accountId,
+                ...(claims.chatgpt_plan_type ? { planType: claims.chatgpt_plan_type } : {}),
+                ...(typeof payload?.email === 'string' ? { email: payload.email } : {}),
+            };
+        }
+    }
+    return {};
+}
+export async function exchangeCode(deps, code, verifier) {
+    const body = new URLSearchParams({
+        grant_type: 'authorization_code',
+        client_id: deps.protocol.clientId,
+        code,
+        code_verifier: verifier,
+        redirect_uri: redirectUri(deps.protocol),
+    });
+    return tokenRequest(deps, body);
+}
+export async function refreshAccessToken(deps, refreshToken) {
+    const body = new URLSearchParams({
+        grant_type: 'refresh_token',
+        client_id: deps.protocol.clientId,
+        refresh_token: refreshToken,
+        scope: deps.protocol.scope,
+    });
+    return tokenRequest(deps, body);
+}
+async function tokenRequest(deps, body) {
+    let res;
+    try {
+        res = await deps.fetchImpl(`${deps.protocol.issuer}/oauth/token`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/x-www-form-urlencoded' },
+            body: body.toString(),
+            signal: AbortSignal.timeout(10_000),
+        });
+    }
+    catch (err) {
+        // Timeouts and DNS failures are retryable — never an auth-expiry signal.
+        throw new CodexError('transport', redact(err instanceof Error ? err.message : String(err)));
+    }
+    if (!res.ok) {
+        const detail = await errorDetail(res, deps.protocol);
+        // OAuth error codes and bare 401/403 mean this credential generation is dead.
+        if (res.status === 401 ||
+            res.status === 403 ||
+            detail.oauthError === 'invalid_grant' ||
+            detail.oauthError === 'invalid_token' ||
+            detail.oauthError === 'invalid_request') {
+            throw new CodexError('auth_expired', detail.oauthError ?? `HTTP ${res.status}`);
+        }
+        throw new CodexError('transport', `HTTP ${res.status}${detail.snippet}`);
+    }
+    const parsed = (await res.json().catch(() => undefined));
+    if (!parsed?.access_token || typeof parsed.expires_in !== 'number') {
+        throw new CodexError('transport', 'token endpoint returned an unexpected body');
+    }
+    return parsed;
+}
+/** Bounded, redacted body preview plus a parsed OAuth `error` code when present. */
+async function errorDetail(res, _protocol) {
+    let text = '';
+    try {
+        text = await res.text();
+    }
+    catch {
+        return {};
+    }
+    let oauthError;
+    try {
+        const parsed = JSON.parse(text);
+        if (typeof parsed.error === 'string')
+            oauthError = parsed.error;
+    }
+    catch {
+        // not JSON — the snippet below is still useful
+    }
+    // Redact first, truncate second: a token spanning the cut must not leak.
+    const snippet = text ? `: ${redact(text).slice(0, 512)}` : '';
+    return { ...(oauthError ? { oauthError } : {}), ...(snippet ? { snippet } : {}) };
+}
+/**
+ * Start one authorization flow: bind 127.0.0.1:<redirectPort>, build the
+ * authorize URL, and wait for exactly one callback. `openBrowser` is invoked
+ * once the listener is accepting (errors there are not fatal — the URL is
+ * shown in the UI too).
+ */
+export async function startBrowserFlow(deps) {
+    const { protocol, fetchImpl } = deps;
+    const { verifier, challenge } = await generatePkce();
+    const state = generateState();
+    const authUrl = authorizeUrl(protocol, challenge, state);
+    let resolveCompletion;
+    let rejectCompletion;
+    const completion = new Promise((resolve, reject) => {
+        resolveCompletion = resolve;
+        rejectCompletion = reject;
+    });
+    let server;
+    try {
+        server = createServer((req, res) => {
+            const url = new URL(req.url ?? '/', `http://127.0.0.1:${protocol.redirectPort}`);
+            if (url.pathname === protocol.redirectPath) {
+                finish(url, res);
+                return;
+            }
+            res.writeHead(404, { 'content-type': 'text/plain; charset=utf-8' });
+            res.end('Not found');
+        });
+    }
+    catch (err) {
+        throw new CodexError('transport', `could not start the sign-in callback server (${err instanceof Error ? err.message : String(err)})`);
+    }
+    const shutdown = () => {
+        clearTimeout(timer);
+        server.close();
+    };
+    const rejectPending = (err) => {
+        shutdown();
+        rejectCompletion?.(err);
+    };
+    const finish = (url, res) => {
+        const error = url.searchParams.get('error');
+        const code = url.searchParams.get('code');
+        const returnedState = url.searchParams.get('state') ?? '';
+        let failure;
+        if (error) {
+            failure = new CodexError('transport', `authorization was refused: ${error}`);
+        }
+        else if (returnedState.length !== state.length || returnedState !== state) {
+            // Byte-compare over the full length; a mismatch is a CSRF attempt or a stale tab.
+            failure = new CodexError('state_mismatch');
+        }
+        else if (!code) {
+            failure = new CodexError('transport', 'the sign-in callback carried no authorization code');
+        }
+        shutdown();
+        if (failure || !code) {
+            respondHtml(res, false);
+            rejectCompletion?.(failure ?? new CodexError('transport', 'the callback carried no code'));
+            return;
+        }
+        respondHtml(res, true);
+        exchangeCode({ fetchImpl, protocol }, code, verifier).then(resolveCompletion, (err) => {
+            clearTimeout(timer);
+            rejectCompletion?.(err);
+        });
+    };
+    const timer = setTimeout(() => rejectPending(new CodexError('transport', 'the sign-in window timed out')), protocol.authTimeoutMs);
+    await new Promise((resolve, reject) => {
+        server.once('error', (err) => {
+            reject(err.code === 'EADDRINUSE'
+                ? new CodexError('transport', `port ${protocol.redirectPort} is already in use — close whatever holds it` +
+                    ' (often the Codex CLI) and retry')
+                : new CodexError('transport', err.message));
+        });
+        server.listen(protocol.redirectPort, '127.0.0.1', resolve);
+    });
+    deps.openBrowser?.(authUrl);
+    return {
+        authUrl,
+        completion,
+        cancel: (reason) => rejectPending(new CodexError('transport', reason)),
+    };
+}
+/** Small self-contained page; callback values are never interpolated into it. */
+function respondHtml(res, ok) {
+    const body = `<!doctype html><meta charset="utf-8"><title>coja</title>
+<body style="font-family:system-ui;display:grid;place-items:center;height:100vh;margin:0">
+<p style="max-width:28rem;text-align:center;line-height:1.5">${ok ? 'ChatGPT connected. You can close this tab and return to coja.' : 'The ChatGPT sign-in did not complete. Return to coja and try again.'}</p>`;
+    res.writeHead(200, { 'content-type': 'text/html; charset=utf-8', 'cache-control': 'no-store' });
+    res.end(body);
+}
+/** One shared session id per provider instance, as the backend expects. */
+export const newSessionId = () => randomUUID();

package/dist/codex/protocol.js

@@ -0,0 +1,49 @@
+/**
+ * Wire constants for the "Sign in with ChatGPT" provider
+ * (docs/research/chatgpt-subscription-auth.md). These ride OpenAI's public
+ * Codex CLI OAuth client against the undocumented ChatGPT Codex backend;
+ * every value is overridable so tests can point at a local mock.
+ */
+export const CODEX_PROTOCOL = {
+    clientId: 'app_EMoamEEZ73f0CkXaXp7hrann',
+    issuer: 'https://auth.openai.com',
+    redirectPort: 1455,
+    redirectPath: '/auth/callback',
+    scope: 'openid profile email offline_access',
+    responsesUrl: 'https://chatgpt.com/backend-api/codex/responses',
+    clientVersion: '0.144.6',
+    refreshMarginMs: 120_000,
+    authTimeoutMs: 5 * 60_000,
+};
+/** Parameters the Codex backend answers with `400 Unsupported parameter` (naming only the first). */
+export const UNSUPPORTED_BODY_PARAMETERS = [
+    'frequency_penalty',
+    'logit_bias',
+    'max_output_tokens',
+    'max_tool_calls',
+    'metadata',
+    'presence_penalty',
+    'safety_identifier',
+    'seed',
+    'stream_options',
+    'temperature',
+    'top_logprobs',
+    'top_p',
+    'truncation',
+    'user',
+];
+export function authorizeUrl(protocol, challenge, state) {
+    const params = new URLSearchParams({
+        response_type: 'code',
+        client_id: protocol.clientId,
+        redirect_uri: redirectUri(protocol),
+        scope: protocol.scope,
+        code_challenge: challenge,
+        code_challenge_method: 'S256',
+        state,
+        id_token_add_organizations: 'true',
+        codex_cli_simplified_flow: 'true',
+    });
+    return `${protocol.issuer}/oauth/authorize?${params.toString()}`;
+}
+export const redirectUri = (protocol) => `http://localhost:${protocol.redirectPort}${protocol.redirectPath}`;

package/dist/codex/provider.js

@@ -0,0 +1,209 @@
+import { createOpenAI } from '@ai-sdk/openai';
+import { CodexError, redact } from './errors.js';
+import { newSessionId } from './oauth.js';
+import { CODEX_PROTOCOL, UNSUPPORTED_BODY_PARAMETERS } from './protocol.js';
+export function createCodexLanguageModel(deps) {
+    const protocol = deps.protocol ?? CODEX_PROTOCOL;
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    const sessionId = newSessionId();
+    // createOpenAI appends `/responses` to the base URL.
+    const baseURL = protocol.responsesUrl.replace(/\/responses\/?$/, '');
+    const request = async (input, init) => {
+        const rawBody = typeof init?.body === 'string' ? init.body : undefined;
+        const parsedBody = rawBody ? JSON.parse(rawBody) : undefined;
+        const streaming = parsedBody?.stream === true;
+        const url = new URL(typeof input === 'string' ? input : input.toString());
+        url.searchParams.set('client_version', protocol.clientVersion);
+        const issue = async (forceRefresh) => {
+            const token = forceRefresh
+                ? await deps.tokens.forceRefresh()
+                : await deps.tokens.getFreshAccessToken();
+            const effort = deps.reasoningEffort ?? deps.defaultReasoningEffort;
+            try {
+                return await fetchImpl(url, {
+                    ...init,
+                    ...(parsedBody ? { body: JSON.stringify(subscriptionBody(parsedBody, effort)) } : {}),
+                    headers: {
+                        ...Object.fromEntries(new Headers(init?.headers)),
+                        authorization: `Bearer ${token.accessToken}`,
+                        ...(token.accountId ? { 'chatgpt-account-id': token.accountId } : {}),
+                        'openai-beta': 'responses=experimental',
+                        originator: 'codex_cli_rs',
+                        session_id: sessionId,
+                    },
+                });
+            }
+            catch (err) {
+                // DNS/TLS/reset and our own aborts surface as a typed, redacted error
+                // instead of a raw TypeError no one can classify.
+                throw new CodexError('transport', redact(err instanceof Error ? err.message : String(err)));
+            }
+        };
+        let response = await issue(false);
+        if (response.status === 401) {
+            response = await issue(true);
+            if (response.status === 401) {
+                throw new CodexError('auth_expired', 'the request was rejected after a token refresh');
+            }
+        }
+        if (response.status === 429) {
+            const retryAfter = Number(response.headers.get('retry-after'));
+            throw new CodexError('quota', undefined, {
+                ...(Number.isFinite(retryAfter) && retryAfter > 0
+                    ? { retryAfterMs: retryAfter * 1000 }
+                    : {}),
+            });
+        }
+        if (!response.ok) {
+            throw new CodexError(endpointErrorCode(response.status), await bodySnippet(response, protocol));
+        }
+        if (parsedBody && !streaming)
+            return collapseStreamedResponse(response);
+        return response;
+    };
+    const openai = createOpenAI({
+        // Unused: the wrapper replaces the Authorization header on every request.
+        apiKey: 'coja-chatgpt-subscription',
+        baseURL,
+        fetch: request,
+    });
+    return openai.responses(deps.modelId);
+}
+/**
+ * Rewrite the SDK's request body into what the subscription backend accepts.
+ * The backend rejects the whole request when any of the unsupported
+ * parameters is present and names only the first offender, so the list is
+ * enforced here rather than at every call site.
+ */
+export function subscriptionBody(body, reasoningEffort) {
+    const rewritten = { ...body };
+    for (const parameter of UNSUPPORTED_BODY_PARAMETERS)
+        delete rewritten[parameter];
+    rewritten.stream = true;
+    rewritten.store = false;
+    rewritten.parallel_tool_calls = false;
+    if (Array.isArray(rewritten.input)) {
+        rewritten.input = stripServerSideState(rewritten.input);
+    }
+    // The catalog publishes per-model reasoning efforts (including levels the
+    // AI SDK's own provider-option schema does not know, e.g. `ultra`), so the
+    // effort is injected here rather than through provider options. An explicit
+    // `reasoning` on the request always wins.
+    if (reasoningEffort && rewritten.reasoning === undefined) {
+        rewritten.reasoning = { effort: reasoningEffort };
+    }
+    // `store:false` turns: reasoning items must come back encrypted, or a tool
+    // call can lose its required preceding reasoning item.
+    const include = Array.isArray(rewritten.include) ? [...rewritten.include] : [];
+    if (!include.includes('reasoning.encrypted_content'))
+        include.push('reasoning.encrypted_content');
+    rewritten.include = include;
+    return rewritten;
+}
+/**
+ * With `store:false` the backend persists nothing, so input items that carry
+ * server-side ids from a previous response (`msg_…`, `fc_…`, `rs_…`) reference
+ * records that do not exist and the whole request is refused
+ * (`Item with id '…' not found`). `call_id` stays: it is the local key pairing
+ * a `function_call` with its `function_call_output`. `item_reference` entries
+ * only ever point at stored state, so they are dropped outright.
+ */
+export function stripServerSideState(items) {
+    const out = [];
+    for (const item of items) {
+        if (item === null || typeof item !== 'object' || Array.isArray(item)) {
+            out.push(item);
+            continue;
+        }
+        const record = item;
+        if (record.type === 'item_reference')
+            continue;
+        const clone = { ...record };
+        delete clone.id;
+        out.push(clone);
+    }
+    return out;
+}
+/**
+ * `doGenerate` issued a non-streaming request; the backend only speaks
+ * streaming, so the SSE has to collapse into one JSON response. This
+ * backend's `response.completed` carries `output: []` — the turn's items only
+ * ever arrive via `response.output_item.done`, so a completed payload with an
+ * empty output gets the collected items restored.
+ */
+async function collapseStreamedResponse(response) {
+    if (!response.body)
+        throw new CodexError('transport', 'the backend returned no response stream');
+    const events = parseSse(await response.text());
+    let completed;
+    let failure;
+    const items = [];
+    for (const event of events) {
+        if (event.name === 'response.completed')
+            completed = event.data;
+        else if (event.name === 'response.failed' || event.name === 'error')
+            failure = event.data;
+        else if (event.name === 'response.output_item.done') {
+            const item = event.data?.item;
+            if (item !== undefined)
+                items.push(item);
+        }
+    }
+    if (!completed) {
+        const detail = failure ? `: ${JSON.stringify(failure).slice(0, 512)}` : '';
+        throw new CodexError('transport', `the response stream ended without completing${detail}`);
+    }
+    const payload = (completed.response ?? completed);
+    const restored = Array.isArray(payload.output) && payload.output.length > 0
+        ? payload
+        : { ...payload, output: items };
+    return new Response(JSON.stringify(restored), {
+        status: 200,
+        headers: { 'content-type': 'application/json' },
+    });
+}
+/** Minimal SSE reader for the collapse path (enough for this backend's frames). */
+export function parseSse(text) {
+    const events = [];
+    for (const block of text.split(/\r?\n\r?\n|\r\n\r\n/)) {
+        let name = 'message';
+        const dataLines = [];
+        for (const line of block.split(/\r?\n|\r\n/)) {
+            if (line.startsWith(':'))
+                continue;
+            if (line.startsWith('event:'))
+                name = line.slice(6).trim();
+            else if (line.startsWith('data:'))
+                dataLines.push(line.slice(5).trimStart());
+        }
+        const data = dataLines.join('\n');
+        if (data === '' || data === '[DONE]')
+            continue;
+        try {
+            const parsed = JSON.parse(data);
+            events.push({
+                name: typeof parsed.type === 'string' ? parsed.type : name,
+                data: parsed,
+            });
+        }
+        catch {
+            events.push({ name, data: undefined });
+        }
+    }
+    return events;
+}
+/** 4xx on this backend almost always means the request shape drifted or a plan gate. */
+function endpointErrorCode(status) {
+    return status >= 500 ? 'transport' : 'endpoint_changed';
+}
+async function bodySnippet(response, _protocol) {
+    let text = '';
+    try {
+        text = await response.text();
+    }
+    catch {
+        return `HTTP ${response.status}`;
+    }
+    // Redact first, truncate second: a token spanning the cut must not leak.
+    return `HTTP ${response.status}${text ? `: ${redact(text).slice(0, 512)}` : ''}`;
+}

package/dist/context.js

@@ -0,0 +1,8 @@
+import path from 'node:path';
+import { ensureDir, resolveDataDir } from './data-dir.js';
+import { openDb } from './db.js';
+export function createContext(opts = {}) {
+    const dataDir = ensureDir(opts.dataDir ?? resolveDataDir());
+    const db = openDb(path.join(dataDir, 'coja.db'));
+    return { dataDir, db };
+}

package/dist/custom-providers.js

@@ -0,0 +1,134 @@
+import { z } from 'zod';
+import { settings } from './db.js';
+/**
+ * User-added model providers (Setup → "Add model provider"): any endpoint
+ * speaking the OpenAI chat-completions or Anthropic messages protocol at a
+ * custom base URL. Configs live in the settings table as one JSON document —
+ * a handful of entries at most, so a document beats a table — while API keys
+ * go to the SecretStore under the provider id, exactly like built-in keys.
+ */
+const SETTINGS_KEY = 'custom_providers';
+export const CUSTOM_PROVIDER_ID_PREFIX = 'custom-';
+/**
+ * Models arrive as ids, with an optional display name once one is known
+ * (fetched from the endpoint's model list or edited in). Stored configs from
+ * before labels existed hold plain strings — normalized on read.
+ */
+const modelEntrySchema = z.union([
+    z
+        .string()
+        .transform((id) => ({ id: id.trim() }))
+        .pipe(z.object({ id: z.string().min(1).max(200) })),
+    z.object({
+        id: z.string().trim().min(1).max(200),
+        label: z.string().trim().min(1).max(200).optional(),
+    }),
+]);
+const normalizeModels = (models) => {
+    const seen = new Set();
+    const out = [];
+    for (const model of models) {
+        if (!model.id || seen.has(model.id))
+            continue;
+        seen.add(model.id);
+        out.push(model.label ? { id: model.id, label: model.label } : { id: model.id });
+    }
+    return out;
+};
+const modelsSchema = z
+    .array(modelEntrySchema)
+    .min(1, 'Add at least one model')
+    .max(32)
+    .transform(normalizeModels);
+const configSchema = z.object({
+    id: z.string().regex(/^custom-[a-z0-9][a-z0-9-]*$/),
+    name: z.string().min(1).max(64),
+    baseUrl: z.string().url(),
+    apiFormat: z.enum(['openai', 'anthropic']),
+    models: modelsSchema,
+});
+export const addCustomProviderSchema = z.object({
+    name: z.string().trim().min(1, 'Name is required').max(64),
+    baseUrl: z
+        .string()
+        .trim()
+        .min(1, 'Base URL is required')
+        .max(2000)
+        .refine((value) => {
+        try {
+            const url = new URL(value);
+            return url.protocol === 'http:' || url.protocol === 'https:';
+        }
+        catch {
+            return false;
+        }
+    }, 'Base URL must be an http(s) URL'),
+    apiFormat: z.enum(['openai', 'anthropic']),
+    models: modelsSchema,
+    apiKey: z.string().max(4096).optional(),
+});
+/** `deepseek` / `My Proxy 2` → `deepseek` / `my-proxy-2` (the id is `custom-<slug>`). */
+export function slugifyProviderName(name) {
+    const slug = name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 40)
+        .replace(/-+$/g, '');
+    return slug || 'provider';
+}
+function readAll(db) {
+    const raw = settings.get(db, SETTINGS_KEY);
+    if (!raw)
+        return [];
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return [];
+        const out = [];
+        for (const entry of parsed) {
+            const result = configSchema.safeParse(entry);
+            if (result.success)
+                out.push(result.data);
+        }
+        return out;
+    }
+    catch {
+        return [];
+    }
+}
+function writeAll(db, providers) {
+    settings.set(db, SETTINGS_KEY, JSON.stringify(providers));
+}
+export function listCustomProviders(db) {
+    return readAll(db);
+}
+export function getCustomProvider(db, id) {
+    return readAll(db).find((provider) => provider.id === id);
+}
+/**
+ * Adds (or replaces — same id means an intentional edit) a custom provider
+ * from a validated request. Returns the saved config (with its id) and the
+ * new full list.
+ */
+export function saveCustomProvider(db, request) {
+    const id = `${CUSTOM_PROVIDER_ID_PREFIX}${slugifyProviderName(request.name)}`;
+    const rest = readAll(db).filter((provider) => provider.id !== id);
+    const saved = {
+        id,
+        name: request.name,
+        baseUrl: request.baseUrl,
+        apiFormat: request.apiFormat,
+        models: normalizeModels(request.models.map((m) => (typeof m === 'string' ? { id: m } : m))),
+    };
+    writeAll(db, [...rest, saved]);
+    return { saved, providers: readAll(db) };
+}
+export function deleteCustomProvider(db, id) {
+    const providers = readAll(db);
+    const rest = providers.filter((provider) => provider.id !== id);
+    if (rest.length === providers.length)
+        return false;
+    writeAll(db, rest);
+    return true;
+}

package/dist/data-dir.js

@@ -0,0 +1,25 @@
+import { mkdirSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+/**
+ * Per-user application data directory (SQLite database, app-managed bare
+ * clones). Override with `COJA_DATA_DIR` — tests and scratch runs use that.
+ */
+export function resolveDataDir(env = process.env) {
+    const override = env.COJA_DATA_DIR;
+    if (override)
+        return path.resolve(override);
+    const home = os.homedir();
+    switch (process.platform) {
+        case 'darwin':
+            return path.join(home, 'Library', 'Application Support', 'coja');
+        case 'win32':
+            return path.join(env.APPDATA ?? path.join(home, 'AppData', 'Roaming'), 'coja');
+        default:
+            return path.join(env.XDG_DATA_HOME ?? path.join(home, '.local', 'share'), 'coja');
+    }
+}
+export function ensureDir(dir) {
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}