@4onstudios/iris-agent 0.1.0

package/dist/api/core/library/terminalAutoApproveSettings.d.ts

@@ -0,0 +1,32 @@
+export type TerminalAutoApproveRuleValue = boolean | {
+    approve: boolean;
+    matchCommandLine?: boolean;
+};
+export type TerminalAutoApproveRules = Record<string, TerminalAutoApproveRuleValue>;
+export declare const TERMINAL_AUTO_APPROVE_RULES_STORAGE_KEY = "settings.terminalAutoApproveRulesJson";
+export declare const TERMINAL_AUTO_APPROVE_RULES_SETTING_ID = "terminalAutoApproveRulesJson";
+export declare function sanitizeTerminalAutoApproveRules(input: unknown): TerminalAutoApproveRules | undefined;
+export declare function parseTerminalAutoApproveRulesJson(raw: string | undefined | null): {
+    rules?: TerminalAutoApproveRules;
+    error?: string;
+};
+export declare function getStoredTerminalAutoApproveRules(storage?: Pick<Storage, "getItem"> | null | undefined): TerminalAutoApproveRules | undefined;
+export declare function buildExactCommandLineAutoApproveRuleKey(commandLine: string): string;
+export declare function suggestTerminalAutoApproveRule(commandLine: string): {
+    ruleKey: string;
+    ruleValue: TerminalAutoApproveRuleValue;
+    strategy: "exact" | "narrow";
+};
+export declare function saveExactTerminalAutoApproveRule(commandLine: string, storage?: Pick<Storage, "getItem" | "setItem"> | null | undefined): {
+    ruleKey: string;
+    rules: TerminalAutoApproveRules;
+    rawValue: string;
+} | undefined;
+export declare function saveTerminalAutoApproveRule(commandLine: string, storage?: Pick<Storage, "getItem" | "setItem"> | null | undefined): {
+    ruleKey: string;
+    ruleValue: TerminalAutoApproveRuleValue;
+    rules: TerminalAutoApproveRules;
+    rawValue: string;
+    strategy: "exact" | "narrow";
+} | undefined;
+export declare function getTerminalAutoApproveRulesFingerprint(rules: TerminalAutoApproveRules | undefined): string;

package/dist/api/core/library/terminalAutoApproveSettings.js

@@ -0,0 +1,529 @@
+import { escapeRegExp } from "./regexEscape.js";
+export const TERMINAL_AUTO_APPROVE_RULES_STORAGE_KEY = "settings.terminalAutoApproveRulesJson";
+export const TERMINAL_AUTO_APPROVE_RULES_SETTING_ID = "terminalAutoApproveRulesJson";
+const WRAPPER_PROGRAMS = new Set([
+    "sudo",
+    "doas",
+    "time",
+    "command",
+    "builtin",
+    "exec",
+    "nice",
+    "ionice",
+    "nohup",
+    "env",
+    "xargs",
+    "stdbuf",
+    "unbuffer",
+    "script",
+    "timeout",
+]);
+const SHELL_PROGRAMS = new Set([
+    "bash",
+    "sh",
+    "zsh",
+    "fish",
+    "ksh",
+    "csh",
+    "tcsh",
+    "dash",
+    "pwsh",
+    "powershell",
+    "powershell.exe",
+    "cmd",
+    "cmd.exe",
+]);
+const NEVER_AUTO_APPROVE_COMMANDS = new Set([
+    "bash",
+    "sh",
+    "zsh",
+    "fish",
+    "ksh",
+    "csh",
+    "tcsh",
+    "dash",
+    "pwsh",
+    "powershell",
+    "powershell.exe",
+    "cmd",
+    "cmd.exe",
+    "python",
+    "python3",
+    "node",
+    "ruby",
+    "perl",
+    "php",
+    "lua",
+    "eval",
+    "exec",
+    "source",
+    "sudo",
+    "su",
+    "doas",
+    "curl",
+    "wget",
+    "invoke-restmethod",
+    "invoke-webrequest",
+    "irm",
+    "iwr",
+]);
+const COMMANDS_WITH_SUBCOMMANDS = new Set([
+    "git",
+    "npm",
+    "npx",
+    "yarn",
+    "docker",
+    "kubectl",
+    "cargo",
+    "dotnet",
+    "mvn",
+    "gradle",
+]);
+const COMMANDS_WITH_SUB_SUB_COMMANDS = new Set(["npm run", "yarn run"]);
+const ENV_ASSIGN_RE = /^[A-Za-z_][A-Za-z0-9_]*=.*$/;
+function getPreviousNonWhitespaceChar(input, index) {
+    for (let cursor = index; cursor >= 0; cursor--) {
+        const char = input[cursor];
+        if (!/\s/.test(char)) {
+            return char;
+        }
+    }
+    return undefined;
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeCommandKeyword(token) {
+    if (!token) {
+        return undefined;
+    }
+    const unquoted = token.replace(/^['"]|['"]$/g, "");
+    if (!unquoted) {
+        return undefined;
+    }
+    const parts = unquoted.split(/[\\/]/);
+    const base = parts[parts.length - 1]?.toLowerCase() ?? "";
+    const normalized = base.replace(/\.(?:exe|cmd|bat|ps1)$/i, "");
+    return normalized || undefined;
+}
+function splitSegments(command) {
+    const segments = [];
+    let current = "";
+    let inSingle = false;
+    let inDouble = false;
+    const push = () => {
+        const trimmed = current.trim();
+        if (trimmed) {
+            segments.push(trimmed);
+        }
+        current = "";
+    };
+    for (let index = 0; index < command.length; index++) {
+        const char = command[index];
+        if (inSingle) {
+            current += char;
+            if (char === "'") {
+                inSingle = false;
+            }
+            continue;
+        }
+        if (inDouble) {
+            if (char === "\\" && index + 1 < command.length) {
+                current += char + command[index + 1];
+                index++;
+                continue;
+            }
+            current += char;
+            if (char === '"') {
+                inDouble = false;
+            }
+            continue;
+        }
+        if (char === "\\" && index + 1 < command.length) {
+            current += char + command[index + 1];
+            index++;
+            continue;
+        }
+        if (char === "'") {
+            inSingle = true;
+            current += char;
+            continue;
+        }
+        if (char === '"') {
+            inDouble = true;
+            current += char;
+            continue;
+        }
+        if (char === "|" || char === ";") {
+            if (command[index + 1] === "|" || command[index + 1] === "&") {
+                push();
+                index++;
+                continue;
+            }
+            push();
+            continue;
+        }
+        if (char === "&" && command[index + 1] === "&") {
+            push();
+            index++;
+            continue;
+        }
+        if (char === "&") {
+            const prev = getPreviousNonWhitespaceChar(command, index - 1);
+            const next = command[index + 1];
+            const isRedirectAmpersand = prev === ">" || prev === "<" || next === ">";
+            if (!isRedirectAmpersand) {
+                push();
+                continue;
+            }
+        }
+        current += char;
+    }
+    push();
+    return segments;
+}
+function tokenize(segment) {
+    const tokens = [];
+    let current = "";
+    let inSingle = false;
+    let inDouble = false;
+    let hasContent = false;
+    for (let index = 0; index < segment.length; index++) {
+        const char = segment[index];
+        if (inSingle) {
+            if (char === "'") {
+                inSingle = false;
+            }
+            else {
+                current += char;
+            }
+            continue;
+        }
+        if (inDouble) {
+            if (char === "\\" && index + 1 < segment.length) {
+                const next = segment[index + 1];
+                if (next === "\\" || next === '"' || next === "$" || next === "`") {
+                    current += next;
+                    index++;
+                    continue;
+                }
+            }
+            if (char === '"') {
+                inDouble = false;
+            }
+            else {
+                current += char;
+            }
+            continue;
+        }
+        if (char === "\\" && index + 1 < segment.length) {
+            current += segment[index + 1];
+            index++;
+            hasContent = true;
+            continue;
+        }
+        if (char === "'") {
+            inSingle = true;
+            hasContent = true;
+            continue;
+        }
+        if (char === '"') {
+            inDouble = true;
+            hasContent = true;
+            continue;
+        }
+        if (/\s/.test(char)) {
+            if (current.length > 0 || hasContent) {
+                tokens.push(current);
+                current = "";
+                hasContent = false;
+            }
+            continue;
+        }
+        current += char;
+        hasContent = true;
+    }
+    if (current.length > 0 || hasContent) {
+        tokens.push(current);
+    }
+    return tokens;
+}
+function stripPrefixesAndWrappers(rawTokens) {
+    let index = 0;
+    while (index < rawTokens.length && ENV_ASSIGN_RE.test(rawTokens[index])) {
+        index++;
+    }
+    while (index < rawTokens.length) {
+        const token = normalizeCommandKeyword(rawTokens[index]);
+        if (!token || !WRAPPER_PROGRAMS.has(token)) {
+            break;
+        }
+        index++;
+        while (index < rawTokens.length) {
+            const next = rawTokens[index];
+            if (next === "--") {
+                index++;
+                break;
+            }
+            if (next.startsWith("-")) {
+                index++;
+                continue;
+            }
+            if (ENV_ASSIGN_RE.test(next)) {
+                index++;
+                continue;
+            }
+            if ((token === "timeout" || token === "nice" || token === "ionice") && /^\d/.test(next)) {
+                index++;
+                continue;
+            }
+            break;
+        }
+    }
+    return rawTokens.slice(index);
+}
+function extractShellCommand(tokens) {
+    const head = normalizeCommandKeyword(tokens[0]);
+    if (!head || !SHELL_PROGRAMS.has(head)) {
+        return undefined;
+    }
+    for (let index = 1; index < tokens.length; index++) {
+        const token = tokens[index];
+        if (!token) {
+            continue;
+        }
+        if (/^--(?:command)$/i.test(token) || /^-(?:c|Command)$/i.test(token)) {
+            return tokens[index + 1];
+        }
+        if (/^-[A-Za-z]+$/.test(token) && token.toLowerCase().includes("c")) {
+            return tokens[index + 1];
+        }
+    }
+    return undefined;
+}
+function extractEffectiveCommands(commandLine, depth = 0) {
+    if (depth > 8) {
+        return [];
+    }
+    const commands = [];
+    for (const segment of splitSegments(commandLine)) {
+        const rawTokens = tokenize(segment);
+        const tokens = stripPrefixesAndWrappers(rawTokens);
+        if (tokens.length === 0) {
+            continue;
+        }
+        const nested = extractShellCommand(tokens);
+        if (nested) {
+            commands.push(...extractEffectiveCommands(nested, depth + 1));
+            continue;
+        }
+        commands.push(tokens.join(" "));
+    }
+    return commands;
+}
+function isNavigationOnlyCommand(command) {
+    return /^(cd|set-location)\b/i.test(command.trim());
+}
+function findNextNonFlagArg(parts, startIndex) {
+    for (let index = startIndex; index < parts.length; index++) {
+        if (!parts[index].startsWith("-")) {
+            return index;
+        }
+    }
+    return undefined;
+}
+export function sanitizeTerminalAutoApproveRules(input) {
+    if (!isPlainObject(input)) {
+        return undefined;
+    }
+    const normalized = {};
+    for (const [key, value] of Object.entries(input)) {
+        const trimmedKey = key.trim();
+        if (!trimmedKey) {
+            continue;
+        }
+        if (typeof value === "boolean") {
+            normalized[trimmedKey] = value;
+            continue;
+        }
+        if (isPlainObject(value) &&
+            typeof value.approve === "boolean" &&
+            (value.matchCommandLine === undefined ||
+                typeof value.matchCommandLine === "boolean")) {
+            normalized[trimmedKey] = value.matchCommandLine === true
+                ? { approve: value.approve, matchCommandLine: true }
+                : { approve: value.approve };
+        }
+    }
+    return Object.keys(normalized).length > 0 ? normalized : undefined;
+}
+export function parseTerminalAutoApproveRulesJson(raw) {
+    const trimmed = raw?.trim() || "";
+    if (!trimmed) {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        const rules = sanitizeTerminalAutoApproveRules(parsed);
+        if (!rules) {
+            return {
+                error: "Rules must be a JSON object whose values are booleans or { approve, matchCommandLine } objects.",
+            };
+        }
+        return { rules };
+    }
+    catch (error) {
+        return {
+            error: error.message || "Invalid JSON",
+        };
+    }
+}
+export function getStoredTerminalAutoApproveRules(storage = typeof window !== "undefined" ? window.localStorage : null) {
+    if (!storage) {
+        return undefined;
+    }
+    try {
+        const raw = storage.getItem(TERMINAL_AUTO_APPROVE_RULES_STORAGE_KEY);
+        return parseTerminalAutoApproveRulesJson(raw).rules;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function buildExactCommandLineAutoApproveRuleKey(commandLine) {
+    const trimmed = commandLine.trim();
+    return `/^${escapeRegExp(trimmed)}$/`;
+}
+export function suggestTerminalAutoApproveRule(commandLine) {
+    const trimmed = commandLine.trim();
+    if (!trimmed) {
+        return {
+            ruleKey: buildExactCommandLineAutoApproveRuleKey(commandLine),
+            ruleValue: { approve: true, matchCommandLine: true },
+            strategy: "exact",
+        };
+    }
+    const effectiveCommands = extractEffectiveCommands(trimmed).filter((command) => !isNavigationOnlyCommand(command));
+    if (effectiveCommands.length !== 1) {
+        return {
+            ruleKey: buildExactCommandLineAutoApproveRuleKey(trimmed),
+            ruleValue: { approve: true, matchCommandLine: true },
+            strategy: "exact",
+        };
+    }
+    const parts = effectiveCommands[0].trim().split(/\s+/);
+    const baseCommand = parts[0]?.toLowerCase();
+    if (!baseCommand || NEVER_AUTO_APPROVE_COMMANDS.has(baseCommand)) {
+        return {
+            ruleKey: buildExactCommandLineAutoApproveRuleKey(trimmed),
+            ruleValue: { approve: true, matchCommandLine: true },
+            strategy: "exact",
+        };
+    }
+    if (COMMANDS_WITH_SUBCOMMANDS.has(baseCommand)) {
+        const subCommandIndex = findNextNonFlagArg(parts, 1);
+        if (subCommandIndex !== undefined) {
+            const baseSubCommand = `${parts[0]} ${parts[subCommandIndex]}`.toLowerCase();
+            if (COMMANDS_WITH_SUB_SUB_COMMANDS.has(baseSubCommand)) {
+                const subSubCommandIndex = findNextNonFlagArg(parts, subCommandIndex + 1);
+                if (subSubCommandIndex !== undefined) {
+                    return {
+                        ruleKey: parts.slice(0, subSubCommandIndex + 1).join(" "),
+                        ruleValue: true,
+                        strategy: "narrow",
+                    };
+                }
+            }
+            return {
+                ruleKey: parts.slice(0, subCommandIndex + 1).join(" "),
+                ruleValue: true,
+                strategy: "narrow",
+            };
+        }
+    }
+    return {
+        ruleKey: parts[0],
+        ruleValue: true,
+        strategy: "narrow",
+    };
+}
+export function saveExactTerminalAutoApproveRule(commandLine, storage = typeof window !== "undefined" ? window.localStorage : null) {
+    const trimmed = commandLine.trim();
+    if (!trimmed || !storage) {
+        return undefined;
+    }
+    const existing = getStoredTerminalAutoApproveRules(storage) || {};
+    const ruleKey = buildExactCommandLineAutoApproveRuleKey(trimmed);
+    const rules = {
+        ...existing,
+        [ruleKey]: {
+            approve: true,
+            matchCommandLine: true,
+        },
+    };
+    const rawValue = JSON.stringify(rules, null, 2);
+    storage.setItem(TERMINAL_AUTO_APPROVE_RULES_STORAGE_KEY, rawValue);
+    if (typeof window !== "undefined") {
+        window.dispatchEvent(new CustomEvent("settingsChanged", {
+            detail: {
+                key: TERMINAL_AUTO_APPROVE_RULES_SETTING_ID,
+                value: rawValue,
+                settings: {
+                    [TERMINAL_AUTO_APPROVE_RULES_SETTING_ID]: rawValue,
+                },
+            },
+        }));
+    }
+    return { ruleKey, rules, rawValue };
+}
+export function saveTerminalAutoApproveRule(commandLine, storage = typeof window !== "undefined" ? window.localStorage : null) {
+    const trimmed = commandLine.trim();
+    if (!trimmed || !storage) {
+        return undefined;
+    }
+    const existing = getStoredTerminalAutoApproveRules(storage) || {};
+    const suggestion = suggestTerminalAutoApproveRule(trimmed);
+    const rules = {
+        ...existing,
+        [suggestion.ruleKey]: suggestion.ruleValue,
+    };
+    const rawValue = JSON.stringify(rules, null, 2);
+    storage.setItem(TERMINAL_AUTO_APPROVE_RULES_STORAGE_KEY, rawValue);
+    if (typeof window !== "undefined") {
+        window.dispatchEvent(new CustomEvent("settingsChanged", {
+            detail: {
+                key: TERMINAL_AUTO_APPROVE_RULES_SETTING_ID,
+                value: rawValue,
+                settings: {
+                    [TERMINAL_AUTO_APPROVE_RULES_SETTING_ID]: rawValue,
+                },
+            },
+        }));
+    }
+    return {
+        ruleKey: suggestion.ruleKey,
+        ruleValue: suggestion.ruleValue,
+        rules,
+        rawValue,
+        strategy: suggestion.strategy,
+    };
+}
+export function getTerminalAutoApproveRulesFingerprint(rules) {
+    if (!rules) {
+        return "";
+    }
+    const entries = Object.entries(rules)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, value]) => [
+        key,
+        typeof value === "boolean"
+            ? value
+            : {
+                approve: value.approve,
+                ...(value.matchCommandLine === true
+                    ? { matchCommandLine: true }
+                    : {}),
+            },
+    ]);
+    return JSON.stringify(entries);
+}

package/dist/api/core/library/workspaceIdentity.d.ts

@@ -0,0 +1,10 @@
+import type { WorkspaceNode } from "./workspaceSummary.js";
+type WorkspaceRootOptions = {
+    preferDesktopRoot?: boolean;
+    allowVirtualRoot?: boolean;
+    fallbackToTreePath?: boolean;
+};
+export declare const getWorkspaceTree: () => WorkspaceNode | null;
+export declare const getWorkspaceRoot: (options?: WorkspaceRootOptions) => string | undefined;
+export declare const getWorkspaceDisplayName: () => string;
+export {};

package/dist/api/core/library/workspaceIdentity.js

@@ -0,0 +1,49 @@
+import { getDesktopWorkspacePath } from "./desktopWorkspace.js";
+const isNonEmptyString = (value) => typeof value === "string" && value.trim().length > 0;
+const isVirtualWorkspaceRoot = (root) => root.startsWith("/workspace/");
+export const getWorkspaceTree = () => {
+    if (typeof window === "undefined") {
+        return null;
+    }
+    return (window.workspaceStructure ||
+        window.tauriWorkspaceStructure ||
+        null);
+};
+export const getWorkspaceRoot = (options = {}) => {
+    if (typeof window === "undefined") {
+        return undefined;
+    }
+    const { preferDesktopRoot = true, allowVirtualRoot = true, fallbackToTreePath = true, } = options;
+    const candidates = [];
+    if (preferDesktopRoot) {
+        candidates.push(getDesktopWorkspacePath());
+    }
+    candidates.push(window.workspaceRoot);
+    if (fallbackToTreePath) {
+        candidates.push(getWorkspaceTree()?.path);
+    }
+    if (!preferDesktopRoot) {
+        candidates.push(getDesktopWorkspacePath());
+    }
+    for (const candidate of candidates) {
+        if (!isNonEmptyString(candidate)) {
+            continue;
+        }
+        if (!allowVirtualRoot && isVirtualWorkspaceRoot(candidate)) {
+            continue;
+        }
+        return candidate;
+    }
+    return undefined;
+};
+export const getWorkspaceDisplayName = () => {
+    const root = getWorkspaceTree();
+    const pathCandidate = getWorkspaceRoot({ preferDesktopRoot: false }) ||
+        (typeof root?.name === "string" ? root.name : "");
+    const normalized = String(pathCandidate).trim();
+    if (!normalized) {
+        return "Workspace";
+    }
+    const segments = normalized.split(/[/\\]/).filter(Boolean);
+    return segments[segments.length - 1] || "Workspace";
+};

package/dist/api/core/library/workspaceSummary.d.ts

@@ -0,0 +1,19 @@
+export type WorkspaceNode = {
+    type?: string;
+    name?: string;
+    path?: string;
+    children?: WorkspaceNode[];
+};
+export type WorkspaceSummary = {
+    hasRoot: boolean;
+    fileCount: number;
+    isDefinitelyEmpty: boolean;
+};
+export declare const countWorkspaceFiles: (node?: WorkspaceNode | null) => number;
+export declare const getWorkspaceSummaryFromRoot: (root?: WorkspaceNode | null) => WorkspaceSummary;
+export declare const collectWorkspaceFilePaths: (root?: WorkspaceNode | null) => Set<string>;
+export declare const shouldShowEmptyWorkspaceState: ({ summary, currentFile, activeTab, }: {
+    summary: WorkspaceSummary;
+    currentFile?: unknown;
+    activeTab?: string | null;
+}) => boolean;

package/dist/api/core/library/workspaceSummary.js

@@ -0,0 +1,35 @@
+export const countWorkspaceFiles = (node) => {
+    if (!node)
+        return 0;
+    if (node.type === "file")
+        return 1;
+    if (!Array.isArray(node.children) || node.children.length === 0)
+        return 0;
+    return node.children.reduce((total, child) => total + countWorkspaceFiles(child), 0);
+};
+export const getWorkspaceSummaryFromRoot = (root) => {
+    const hasRoot = root != null;
+    const children = root?.children;
+    return {
+        hasRoot,
+        fileCount: countWorkspaceFiles(root),
+        isDefinitelyEmpty: hasRoot && Array.isArray(children) && children.length === 0,
+    };
+};
+export const collectWorkspaceFilePaths = (root) => {
+    const paths = new Set();
+    const walk = (node) => {
+        if (!node)
+            return;
+        if (node.type === "file" && typeof node.path === "string" && node.path) {
+            paths.add(node.path);
+            return;
+        }
+        if (Array.isArray(node.children)) {
+            node.children.forEach(walk);
+        }
+    };
+    walk(root);
+    return paths;
+};
+export const shouldShowEmptyWorkspaceState = ({ summary, currentFile, activeTab, }) => summary.hasRoot && !currentFile && !activeTab;