@ishlabs/cli 0.8.1 → 0.8.2

package/dist/lib/output.js

@@ -16,15 +16,20 @@ export function setVerbose(v) { _verbose = v; }
 export function setFields(fields) { _fields = fields; }
 const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const TIMESTAMP_KEYS = new Set(["created_at", "updated_at"]);
+const PAGINATION_KEYS = new Set(["items", "total", "limit", "offset"]);
 /**
  * Strip UUID-valued fields, null/undefined values, and timestamps.
  * Preserves alias, name, label, status, and other meaningful fields.
+ *
+ * When `keepIds` is true, `id` and `*_id` keys (and their UUID values) are
+ * preserved — used for write-path responses so agents always get a canonical
+ * handle without having to set --verbose.
  */
-function leanJson(data) {
+function leanJson(data, keepIds = false) {
     if (data === null || data === undefined)
         return undefined;
     if (Array.isArray(data)) {
-        return data.map(leanJson).filter((v) => v !== undefined);
+        return data.map((v) => leanJson(v, keepIds)).filter((v) => v !== undefined);
     }
     if (typeof data !== "object")
         return data;
@@ -36,6 +41,12 @@ function leanJson(data) {
             result[key] = value;
             continue;
         }
+        // Write-path: preserve canonical identifier keys
+        if (keepIds && (key === "id" || key.endsWith("_id"))) {
+            if (value !== null && value !== undefined)
+                result[key] = value;
+            continue;
+        }
         // Strip null/undefined
         if (value === null || value === undefined)
             continue;
@@ -47,7 +58,7 @@ function leanJson(data) {
             continue;
         // Recurse into objects/arrays
         if (typeof value === "object") {
-            const cleaned = leanJson(value);
+            const cleaned = leanJson(value, keepIds);
             if (cleaned !== undefined && !(Array.isArray(cleaned) && cleaned.length === 0)) {
                 result[key] = cleaned;
             }
@@ -58,7 +69,30 @@ function leanJson(data) {
     return Object.keys(result).length > 0 ? result : undefined;
 }
 /**
- * Pick only specified fields from an object. Applied after lean transform.
+ * Detect a paginated list wrapper: `{items: [...], total?, limit?, offset?}`.
+ * Used so `--fields` filters per-item shape without dropping pagination metadata.
+ */
+function isListWrapper(data) {
+    if (data === null || typeof data !== "object" || Array.isArray(data))
+        return false;
+    const obj = data;
+    if (!Array.isArray(obj.items))
+        return false;
+    // Conservative: only treat as a wrapper if every top-level key is recognized
+    // pagination metadata. Otherwise an entity that happens to expose a nested
+    // `items` field would be unwrapped by mistake.
+    for (const key of Object.keys(obj)) {
+        if (!PAGINATION_KEYS.has(key))
+            return false;
+    }
+    return true;
+}
+/**
+ * Pick only specified fields from each item.
+ *
+ * Rule: `--fields` projects per-item shape; the wrapper (pagination metadata
+ * for paginated lists, top-level object for `get`-style responses) stays
+ * stable so downstream JSON parsers don't have to branch on flag presence.
  */
 function pickFields(data, fields) {
     if (Array.isArray(data)) {
@@ -66,9 +100,9 @@ function pickFields(data, fields) {
     }
     if (typeof data === "object" && data !== null) {
         const obj = data;
-        // Unwrap { items: [...] } wrapper before picking fields
-        if (Array.isArray(obj.items)) {
-            return pickFields(obj.items, fields);
+        // Preserve list wrapper; project items only.
+        if (isListWrapper(obj)) {
+            return { ...obj, items: pickFields(obj.items, fields) };
         }
         const result = {};
         for (const field of fields) {
@@ -80,8 +114,16 @@ function pickFields(data, fields) {
     return data;
 }
 /** Serialize data as JSON, applying lean transform and field selection. */
-function jsonOutput(data) {
-    let out = _verbose ? data : leanJson(data);
+function jsonOutput(data, options = {}) {
+    let out;
+    if (_verbose || options.preProjected) {
+        // Verbose: full payload. preProjected: caller already chose the fields,
+        // so don't strip again (otherwise leanJson would drop e.g. created_at).
+        out = data;
+    }
+    else {
+        out = leanJson(data, options.writePath);
+    }
     if (_fields && _fields.length > 0) {
         out = pickFields(out, _fields);
     }
@@ -100,9 +142,9 @@ function injectAliases(items, prefix, idField = "id") {
     }
 }
 // --- JSON mode ---
-export function output(data, json) {
+export function output(data, json, options = {}) {
     if (json) {
-        console.log(jsonOutput(data));
+        console.log(jsonOutput(data, options));
         return;
     }
     if (data === null || data === undefined)
@@ -203,13 +245,31 @@ function suggestionsForError(err) {
 export function outputError(err, json) {
     const suggestions = suggestionsForError(err);
     if (err instanceof ApiError) {
+        // Surface backend-structured fields when present in the response body
+        // (e.g. 422 errors return `errors: [{loc, msg, type, input, allowed_values}]`,
+        // and some endpoints attach `suggestions: [...]`). Merging these gives
+        // JSON consumers everything the server told us, without losing the
+        // client-side suggestion mapping.
+        let bodyErrors;
+        let bodySuggestions;
+        if (err.body && typeof err.body === "object") {
+            const body = err.body;
+            if (Array.isArray(body.errors))
+                bodyErrors = body.errors;
+            if (Array.isArray(body.suggestions))
+                bodySuggestions = body.suggestions;
+        }
+        const mergedSuggestions = bodySuggestions
+            ? Array.from(new Set([...bodySuggestions.map(String), ...suggestions]))
+            : suggestions;
         if (json) {
             console.error(JSON.stringify({
                 error: err.message,
                 error_code: err.error_code,
                 status: err.status,
                 retryable: err.retryable,
-                ...(suggestions.length > 0 && { suggestions }),
+                ...(bodyErrors !== undefined && { errors: bodyErrors }),
+                ...(mergedSuggestions.length > 0 && { suggestions: mergedSuggestions }),
             }));
         }
         else {
@@ -219,7 +279,20 @@ export function outputError(err, json) {
             else {
                 console.error(`Error: ${err.message}`);
             }
-            for (const s of suggestions)
+            if (Array.isArray(bodyErrors)) {
+                for (const entry of bodyErrors) {
+                    if (entry && typeof entry === "object") {
+                        const e = entry;
+                        const loc = Array.isArray(e.loc) ? e.loc.join(".") : "";
+                        const msg = e.msg ? String(e.msg) : "";
+                        const allowed = Array.isArray(e.allowed_values)
+                            ? ` (allowed: ${e.allowed_values.join(", ")})`
+                            : "";
+                        console.error(`  • ${loc}${loc ? ": " : ""}${msg}${allowed}`);
+                    }
+                }
+            }
+            for (const s of mergedSuggestions)
                 console.error(`  → ${s}`);
         }
     }
@@ -290,6 +363,22 @@ function formatLabel(key) {
         .replace(/\b\w/g, (c) => c.toUpperCase());
 }
 // --- Workspace formatting ---
+/**
+ * Default workspace fields exposed in both TTY tables and JSON output.
+ * Anything not in this set (e.g. has_figma_token) is hidden unless --verbose.
+ */
+const WORKSPACE_DEFAULT_FIELDS = ["alias", "name", "base_url", "created_at"];
+function projectWorkspace(workspace, options = {}) {
+    const result = {};
+    if (options.writePath && workspace.id !== null && workspace.id !== undefined) {
+        result.id = workspace.id;
+    }
+    for (const field of WORKSPACE_DEFAULT_FIELDS) {
+        if (field in workspace)
+            result[field] = workspace[field];
+    }
+    return result;
+}
 export function formatWorkspaceList(workspaces, json) {
     if (workspaces.length === 0) {
         if (json)
@@ -300,19 +389,32 @@ export function formatWorkspaceList(workspaces, json) {
     }
     injectAliases(workspaces, ALIAS_PREFIX.workspace);
     if (json) {
-        console.log(jsonOutput(workspaces));
+        if (_verbose) {
+            console.log(jsonOutput(workspaces));
+        }
+        else {
+            const projected = workspaces.map((w) => projectWorkspace(w));
+            console.log(jsonOutput(projected, { preProjected: true }));
+        }
         return;
     }
     const aliasMap = getAliasMap(ALIAS_PREFIX.workspace);
-    printTable(["#", "NAME", "CREATED"], workspaces.map((w) => [
+    printTable(["#", "NAME", "BASE URL", "CREATED"], workspaces.map((w) => [
         aliasMap.get(String(w.id)) || String(w.id || ""),
         String(w.name || ""),
+        String(w.base_url || "-"),
         formatDate(w.created_at),
     ]));
 }
-export function formatWorkspaceDetail(workspace, json) {
+export function formatWorkspaceDetail(workspace, json, options = {}) {
     if (json) {
-        console.log(jsonOutput(workspace));
+        if (_verbose) {
+            console.log(jsonOutput(workspace, options));
+        }
+        else {
+            const projected = projectWorkspace(workspace, { writePath: options.writePath });
+            console.log(jsonOutput(projected, { ...options, preProjected: true }));
+        }
         return;
     }
     const display = {
@@ -324,6 +426,19 @@ export function formatWorkspaceDetail(workspace, json) {
     };
     printKeyValue(display);
 }
+// --- Site-access formatting ---
+export function formatSiteAccessStatus(summary, json) {
+    if (json) {
+        console.log(jsonOutput(summary));
+        return;
+    }
+    printTable(["METHOD", "STATUS", "ORIGIN"], [
+        ["Basic auth", summary.basic_auth.configured ? "configured" : "-", summary.basic_auth.origin || "-"],
+        ["Session cookie", summary.session_cookie.configured ? "configured" : "-", summary.session_cookie.origin || "-"],
+        ["Login form", summary.login.configured ? "configured" : "-", "-"],
+        ["Public", summary.public_affirmed.affirmed ? "affirmed" : "-", summary.public_affirmed.origin || "-"],
+    ]);
+}
 // --- Study formatting ---
 export function formatStudyList(studies, json) {
     if (studies.length === 0) {
@@ -348,9 +463,9 @@ export function formatStudyList(studies, json) {
         String(s.tester_count ?? "0"),
     ]));
 }
-export function formatStudyDetail(study, json) {
+export function formatStudyDetail(study, json, options = {}) {
     if (json) {
-        console.log(jsonOutput(study));
+        console.log(jsonOutput(study, options));
         return;
     }
     // Header
@@ -397,9 +512,73 @@ export function formatStudyDetail(study, json) {
         ]));
     }
 }
+/**
+ * Stable JSON envelope for `study results`. Schema is fixed regardless of
+ * study state — fields default to `null`, `0`, or `[]` when nothing has run.
+ * Agents can rely on the keys always being present (M4).
+ */
+function buildStudyResultsEnvelope(study) {
+    const allTesters = collectTesters(study);
+    const studyAlias = study.id
+        ? deterministicAlias(ALIAS_PREFIX.study, String(study.id))
+        : null;
+    const completedCount = allTesters.filter((t) => t.status === "completed" || t.status === "complete").length;
+    // Aggregate sentiment across all interactions on all testers.
+    const sentimentCounts = {};
+    let sentimentTotal = 0;
+    for (const t of allTesters) {
+        for (const [label, count] of Object.entries(t.sentimentCounts)) {
+            sentimentCounts[label] = (sentimentCounts[label] || 0) + count;
+            sentimentTotal += count;
+        }
+    }
+    const sentiment = sentimentTotal > 0
+        ? {
+            counts: sentimentCounts,
+            total: sentimentTotal,
+        }
+        : null;
+    // Group interview answers by question for easy parsing.
+    const questions = Array.isArray(study.interview_questions) ? study.interview_questions : [];
+    const interviewAnswers = questions.map((q) => {
+        const qObj = q;
+        const answers = [];
+        for (const t of allTesters) {
+            const a = t.interviewAnswers.find((x) => x.questionId === qObj.id);
+            if (a) {
+                answers.push({
+                    tester_alias: t.id ? deterministicAlias(ALIAS_PREFIX.tester, t.id) : null,
+                    tester_name: t.name,
+                    iteration: t.iterationLabel,
+                    answer: a.answer,
+                });
+            }
+        }
+        return {
+            question: qObj.question || "",
+            type: qObj.type || "text",
+            answers,
+        };
+    });
+    return {
+        study: {
+            alias: studyAlias,
+            name: study.name || null,
+            status: study.status || null,
+            modality: study.modality || null,
+        },
+        tester_count: allTesters.length,
+        completed_count: completedCount,
+        sentiment,
+        interview_answers: interviewAnswers,
+    };
+}
 export function formatStudyResults(study, json) {
     if (json) {
-        console.log(jsonOutput(study));
+        // preProjected: bypass leanJson so the stable envelope keeps documented
+        // empty defaults (sentiment: null, interview_answers[].answers: []) rather
+        // than having them stripped by the lean transform.
+        console.log(jsonOutput(buildStudyResultsEnvelope(study), { preProjected: true }));
         return;
     }
     const allTesters = collectTesters(study);
@@ -595,6 +774,54 @@ export function formatTesterProfileList(profiles, json, limit) {
         console.log(`\n  Showing ${list.length} of ${fullList.length} profiles. Use --limit and --offset for more.`);
     }
 }
+// --- Audience source formatting ---
+export function formatAudienceSource(source, json) {
+    if (source.id) {
+        source.alias = deterministicAlias(ALIAS_PREFIX.testerProfileSource, String(source.id));
+    }
+    if (json) {
+        console.log(jsonOutput(source));
+        return;
+    }
+    const display = {
+        Alias: source.alias || source.id || "-",
+        File: source.original_filename || "-",
+        Kind: source.kind || "-",
+        Status: source.status || "-",
+        "Content-Type": source.content_type || "-",
+    };
+    if (source.extracted_text_length != null) {
+        display["Text length"] = source.extracted_text_length;
+    }
+    if (source.error) {
+        display.Error = source.error;
+    }
+    printKeyValue(display);
+}
+// --- Generated profile list (returned by /tester-profiles/generate) ---
+export function formatGeneratedProfileList(profiles, json) {
+    const list = Array.isArray(profiles) ? profiles : [];
+    if (list.length === 0) {
+        if (json)
+            console.log("[]");
+        else
+            console.log("No profiles generated.");
+        return;
+    }
+    injectAliases(list, ALIAS_PREFIX.testerProfile);
+    if (json) {
+        console.log(jsonOutput(list));
+        return;
+    }
+    printTable(["#", "NAME", "OCCUPATION", "COUNTRY", "GENDER", "AGE"], list.map((p) => [
+        String(p.alias || p.id || ""),
+        String(p.name || ""),
+        String(p.occupation || "-"),
+        String(p.country || "-"),
+        String(p.gender || "-"),
+        formatAge(p.date_of_birth),
+    ]));
+}
 // --- Simulation poll formatting ---
 export function formatSimulationPoll(results, json, isMedia = false) {
     if (results.length === 0) {
@@ -621,6 +848,224 @@ export function formatSimulationPoll(results, json, isMedia = false) {
         ];
     }));
 }
+// --- Ask formatting ---
+function variantLetter(index) {
+    if (index < 26)
+        return String.fromCharCode(65 + index);
+    return `V${index + 1}`;
+}
+export function formatAskList(asks, json) {
+    if (asks.length === 0) {
+        if (json)
+            console.log("[]");
+        else
+            console.log("No asks.");
+        return;
+    }
+    injectAliases(asks, ALIAS_PREFIX.ask);
+    if (json) {
+        console.log(jsonOutput(asks));
+        return;
+    }
+    const aliasMap = getAliasMap(ALIAS_PREFIX.ask);
+    printTable(["#", "NAME", "AUDIENCE", "ROUNDS", "LAST ROUND", "ARCHIVED"], asks.map((a) => [
+        aliasMap.get(String(a.id)) || String(a.id || ""),
+        String(a.name || ""),
+        String(a.audience_count ?? "0"),
+        String(a.round_count ?? "0"),
+        formatDate(a.last_round_at),
+        a.is_archived ? "yes" : "no",
+    ]));
+}
+export function formatAskDetail(ask, json) {
+    if (json) {
+        console.log(jsonOutput(ask));
+        return;
+    }
+    console.log(`${ask.name || "Untitled"} (${ask.id || ""})`);
+    if (ask.description)
+        console.log(String(ask.description));
+    const meta = [];
+    if (ask.is_archived)
+        meta.push("archived");
+    meta.push(formatDate(ask.created_at));
+    console.log(meta.join(" · "));
+    const testers = Array.isArray(ask.testers) ? ask.testers : [];
+    console.log(`\nAudience (${testers.length}):`);
+    if (testers.length > 0) {
+        const rows = testers.slice(0, 20).map((t) => {
+            const obj = t;
+            const profile = obj.tester_profile;
+            const name = String(profile?.name || obj.instance_name || "Unknown");
+            return [
+                obj.id ? deterministicAlias(ALIAS_PREFIX.tester, String(obj.id)) : "-",
+                name,
+                String(obj.status || "-"),
+            ];
+        });
+        printTable(["#", "NAME", "STATUS"], rows);
+        if (testers.length > 20)
+            console.log(`  … and ${testers.length - 20} more`);
+    }
+    const rounds = Array.isArray(ask.rounds) ? ask.rounds : [];
+    if (rounds.length > 0) {
+        console.log(`\nRounds (${rounds.length}):`);
+        for (const r of rounds) {
+            const round = r;
+            const variants = Array.isArray(round.variants) ? round.variants : [];
+            const responses = Array.isArray(round.responses) ? round.responses : [];
+            const completed = responses.filter((x) => x.status === "completed").length;
+            const idx = typeof round.order_index === "number" ? round.order_index : 0;
+            console.log(`  Round ${idx + 1} [${round.status || "-"}] · ${variants.length} variant(s) · ${completed}/${responses.length} responded`);
+            console.log(`    "${truncate(String(round.prompt || ""), 100)}"`);
+        }
+    }
+}
+export function formatRoundDetail(round, json) {
+    if (json) {
+        console.log(jsonOutput(round));
+        return;
+    }
+    const variants = Array.isArray(round.variants) ? round.variants : [];
+    const responses = Array.isArray(round.responses) ? round.responses : [];
+    const idx = typeof round.order_index === "number" ? round.order_index : 0;
+    console.log(`Round ${idx + 1} [${round.status || "-"}]`);
+    console.log(`Prompt: ${round.prompt}`);
+    if (variants.length > 0) {
+        console.log("\nVariants:");
+        variants.forEach((v, i) => {
+            const variant = v;
+            const letter = variantLetter(i);
+            const label = variant.label ? ` "${variant.label}"` : "";
+            const preview = variant.kind === "text"
+                ? truncate(String(variant.content || ""), 80)
+                : `<${variant.kind}>`;
+            console.log(`  [${letter}]${label} (${variant.kind}): ${preview}`);
+        });
+    }
+    if (responses.length > 0) {
+        const completed = responses.filter((r) => r.status === "completed");
+        console.log(`\nResponses: ${completed.length}/${responses.length} completed`);
+    }
+    const summary = round.summary;
+    if (summary?.comment) {
+        console.log("\nSummary:");
+        console.log(`  ${summary.comment}`);
+    }
+}
+function computeVariantStats(round) {
+    const variants = Array.isArray(round.variants) ? round.variants : [];
+    const responses = Array.isArray(round.responses) ? round.responses : [];
+    const stats = variants.map((v, i) => {
+        const variant = v;
+        return {
+            letter: variantLetter(i),
+            label: variant.label ? String(variant.label) : undefined,
+            kind: String(variant.kind || "-"),
+            pickCount: 0,
+            ratingTotal: 0,
+            ratingCount: 0,
+            preview: variant.kind === "text"
+                ? truncate(String(variant.content || ""), 60)
+                : `<${variant.kind}>`,
+        };
+    });
+    const idToIndex = new Map();
+    variants.forEach((v, i) => {
+        const id = v.id;
+        if (id)
+            idToIndex.set(String(id), i);
+    });
+    for (const r of responses) {
+        const resp = r;
+        if (resp.status !== "completed")
+            continue;
+        const pick = resp.variant_pick_id;
+        if (typeof pick === "string") {
+            const idx = idToIndex.get(pick);
+            if (idx !== undefined)
+                stats[idx].pickCount++;
+        }
+        const ratings = resp.variant_ratings;
+        if (ratings && typeof ratings === "object") {
+            for (const [vid, val] of Object.entries(ratings)) {
+                const idx = idToIndex.get(vid);
+                if (idx !== undefined && typeof val === "number") {
+                    stats[idx].ratingTotal += val;
+                    stats[idx].ratingCount++;
+                }
+            }
+        }
+    }
+    return stats;
+}
+export function formatAskResults(ask, json, roundFilter) {
+    const rounds = (Array.isArray(ask.rounds) ? ask.rounds : []);
+    const filtered = roundFilter !== undefined
+        ? rounds.filter((r) => (typeof r.order_index === "number" ? r.order_index : 0) === roundFilter - 1)
+        : rounds;
+    if (json) {
+        const payload = roundFilter !== undefined ? { ...ask, rounds: filtered } : ask;
+        console.log(jsonOutput(payload));
+        return;
+    }
+    console.log(`${ask.name || "Untitled"} — Results`);
+    if (filtered.length === 0) {
+        console.log(roundFilter !== undefined ? `No round ${roundFilter}.` : "No rounds yet.");
+        return;
+    }
+    for (const round of filtered) {
+        const idx = typeof round.order_index === "number" ? round.order_index : 0;
+        const responses = Array.isArray(round.responses) ? round.responses : [];
+        const completed = responses.filter((r) => r.status === "completed");
+        console.log(`\nRound ${idx + 1} [${round.status || "-"}] · ${completed.length}/${responses.length} responded`);
+        console.log(`  Prompt: "${truncate(String(round.prompt || ""), 100)}"`);
+        const stats = computeVariantStats(round);
+        if (stats.length > 0 && (round.wants_pick || round.wants_ratings)) {
+            const hasPick = !!round.wants_pick;
+            const hasRatings = !!round.wants_ratings;
+            const headers = ["#", "LABEL", "KIND"];
+            if (hasPick)
+                headers.push("PICKS");
+            if (hasRatings)
+                headers.push("MEAN RATING");
+            headers.push("PREVIEW");
+            const rows = stats.map((s) => {
+                const row = [s.letter, s.label || "-", s.kind];
+                if (hasPick)
+                    row.push(String(s.pickCount));
+                if (hasRatings) {
+                    row.push(s.ratingCount > 0 ? (s.ratingTotal / s.ratingCount).toFixed(2) : "-");
+                }
+                row.push(s.preview);
+                return row;
+            });
+            console.log("");
+            printTable(headers, rows);
+        }
+        else if (stats.length > 0) {
+            console.log("");
+            printTable(["#", "LABEL", "KIND", "PREVIEW"], stats.map((s) => [s.letter, s.label || "-", s.kind, s.preview]));
+        }
+        if (completed.length > 0) {
+            console.log("\n  Comments:");
+            for (const r of completed.slice(0, 10)) {
+                const resp = r;
+                const comment = resp.comment ? truncate(String(resp.comment), 120) : "-";
+                const tester = resp.tester_id ? deterministicAlias(ALIAS_PREFIX.tester, String(resp.tester_id)) : "-";
+                console.log(`    ${tester}: ${comment}`);
+            }
+            if (completed.length > 10) {
+                console.log(`    … and ${completed.length - 10} more`);
+            }
+        }
+        const summary = round.summary;
+        if (summary?.comment) {
+            console.log("\n  Summary:");
+            console.log(`    ${summary.comment}`);
+        }
+    }
+}
 // --- Config formatting ---
 export function formatConfigList(configs, json) {
     if (configs.length === 0) {

package/dist/lib/paths.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Filesystem paths used by the CLI.
+ *
+ * Honors the `ISH_HOME` environment variable so users on systems with an
+ * XDG layout (or anywhere else) can override the default `~/.ish` root.
+ * Mirrors the pattern used by `gh` (GH_CONFIG_DIR) and `aws` (AWS_CONFIG_FILE).
+ */
+export declare function ishDir(): string;
+export declare function configPath(): string;
+export declare function aliasesPath(): string;
+export declare function binDir(): string;
+export declare function browsersDir(): string;
+export declare function simulationsDir(): string;
+export declare function cloudflaredBin(): string;

package/dist/lib/paths.js

@@ -0,0 +1,36 @@
+/**
+ * Filesystem paths used by the CLI.
+ *
+ * Honors the `ISH_HOME` environment variable so users on systems with an
+ * XDG layout (or anywhere else) can override the default `~/.ish` root.
+ * Mirrors the pattern used by `gh` (GH_CONFIG_DIR) and `aws` (AWS_CONFIG_FILE).
+ */
+import * as path from "node:path";
+import * as os from "node:os";
+function rootDir() {
+    if (process.env.ISH_HOME)
+        return process.env.ISH_HOME;
+    return path.join(os.homedir(), ".ish");
+}
+export function ishDir() {
+    return rootDir();
+}
+export function configPath() {
+    return path.join(rootDir(), "config.json");
+}
+export function aliasesPath() {
+    return path.join(rootDir(), "aliases.json");
+}
+export function binDir() {
+    return path.join(rootDir(), "bin");
+}
+export function browsersDir() {
+    return path.join(rootDir(), "browsers");
+}
+export function simulationsDir() {
+    return path.join(rootDir(), "simulations");
+}
+export function cloudflaredBin() {
+    const exe = process.platform === "win32" ? "cloudflared.exe" : "cloudflared";
+    return path.join(binDir(), exe);
+}