atoo-studio 0.0.1 → 0.0.2

package/dist/src/services/github-ops.js

@@ -0,0 +1,192 @@
+import { execFile } from 'child_process';
+const TIMEOUT = 30000;
+function gh(args, cwd) {
+    return new Promise((resolve, reject) => {
+        execFile('gh', args, { cwd, timeout: TIMEOUT, maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
+            if (err) {
+                reject(new Error(stderr?.trim() || err.message));
+            }
+            else {
+                resolve(stdout);
+            }
+        });
+    });
+}
+function whichGh() {
+    return new Promise((resolve) => {
+        execFile('which', ['gh'], { timeout: 5000 }, (err) => {
+            resolve(!err);
+        });
+    });
+}
+// Cache github status per cwd to avoid repeated detection
+const statusCache = new Map();
+const STATUS_CACHE_TTL = 60000; // 1 minute
+export async function getGitHubStatus(cwd) {
+    const cached = statusCache.get(cwd);
+    if (cached && Date.now() - cached.ts < STATUS_CACHE_TTL) {
+        return cached.status;
+    }
+    const result = { available: false, owner: '', repo: '', canWrite: false };
+    // Check if gh is installed
+    const hasGh = await whichGh();
+    if (!hasGh) {
+        result.unavailableReason = 'GitHub CLI (gh) is not installed';
+        statusCache.set(cwd, { status: result, ts: Date.now() });
+        return result;
+    }
+    // Check for GitHub remote
+    try {
+        const remotes = await new Promise((resolve, reject) => {
+            execFile('git', ['remote', '-v'], { cwd, timeout: 5000 }, (err, stdout) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(stdout);
+            });
+        });
+        const ghRemote = remotes.split('\n').find(line => line.includes('github.com') && line.includes('(push)'));
+        if (!ghRemote) {
+            result.unavailableReason = 'No GitHub remote configured';
+            statusCache.set(cwd, { status: result, ts: Date.now() });
+            return result;
+        }
+        // Parse owner/repo from remote URL
+        // Handles: git@github.com:owner/repo.git, https://github.com/owner/repo.git, etc.
+        const match = ghRemote.match(/github\.com[:/]([^/]+)\/([^/\s]+?)(?:\.git)?(?:\s|$)/);
+        if (!match) {
+            result.unavailableReason = 'Could not parse GitHub remote URL';
+            statusCache.set(cwd, { status: result, ts: Date.now() });
+            return result;
+        }
+        result.owner = match[1];
+        result.repo = match[2];
+    }
+    catch {
+        result.unavailableReason = 'No GitHub remote configured';
+        statusCache.set(cwd, { status: result, ts: Date.now() });
+        return result;
+    }
+    // Check auth status
+    try {
+        const authOut = await gh(['auth', 'status'], cwd);
+        result.available = true;
+        // Check for write scopes
+        // gh auth status outputs scopes like: Token scopes: 'delete_repo', 'gist', 'repo', 'workflow'
+        const hasRepoScope = /['"]repo['"]/.test(authOut) || /Token scopes:.*\brepo\b/.test(authOut);
+        const hasWriteScope = hasRepoScope || /['"]write:/.test(authOut) || /['"]public_repo['"]/.test(authOut);
+        result.canWrite = hasWriteScope;
+    }
+    catch (err) {
+        // gh auth status exits with error if not authenticated, but may still output info to stderr
+        const msg = err.message || '';
+        if (msg.includes('Logged in')) {
+            result.available = true;
+            // Conservative: if we can't parse scopes, assume read-only
+            result.canWrite = /\brepo\b/.test(msg);
+        }
+        else {
+            result.unavailableReason = 'GitHub CLI not authenticated — run "gh auth login"';
+        }
+    }
+    statusCache.set(cwd, { status: result, ts: Date.now() });
+    return result;
+}
+export function clearStatusCache(cwd) {
+    if (cwd) {
+        statusCache.delete(cwd);
+    }
+    else {
+        statusCache.clear();
+    }
+}
+const ISSUE_FIELDS = 'number,title,state,author,labels,createdAt,updatedAt,comments,url,assignees,milestone';
+const PR_FIELDS = 'number,title,state,author,labels,createdAt,updatedAt,comments,url,headRefName,baseRefName,isDraft,mergeable,reviewDecision,additions,deletions,assignees';
+export async function listIssues(cwd, opts = {}) {
+    const { state = 'open', search, limit = 50 } = opts;
+    const args = ['issue', 'list', '--json', ISSUE_FIELDS, '--limit', String(limit + 1), '--state', state];
+    if (search) {
+        args.push('--search', search);
+    }
+    const out = await gh(args, cwd);
+    const items = JSON.parse(out);
+    const hasMore = items.length > limit;
+    if (hasMore)
+        items.length = limit;
+    return { items, hasMore };
+}
+export async function listPulls(cwd, opts = {}) {
+    const { state = 'open', search, limit = 50 } = opts;
+    const args = ['pr', 'list', '--json', PR_FIELDS, '--limit', String(limit + 1), '--state', state];
+    if (search) {
+        args.push('--search', search);
+    }
+    const out = await gh(args, cwd);
+    const items = JSON.parse(out);
+    const hasMore = items.length > limit;
+    if (hasMore)
+        items.length = limit;
+    return { items, hasMore };
+}
+const ISSUE_DETAIL_FIELDS = ISSUE_FIELDS + ',body';
+const PR_DETAIL_FIELDS = PR_FIELDS + ',body';
+export async function getIssueDetail(cwd, number) {
+    const out = await gh(['issue', 'view', String(number), '--json', ISSUE_DETAIL_FIELDS], cwd);
+    const issue = JSON.parse(out);
+    // Fetch comments separately
+    const commentsOut = await gh(['issue', 'view', String(number), '--json', 'comments'], cwd);
+    const { comments: commentsList } = JSON.parse(commentsOut);
+    return {
+        ...issue,
+        comments_list: (commentsList || []).map((c) => ({
+            author: c.author,
+            body: c.body,
+            createdAt: c.createdAt,
+            updatedAt: c.updatedAt,
+        })),
+    };
+}
+export async function getPullDetail(cwd, number) {
+    const out = await gh(['pr', 'view', String(number), '--json', PR_DETAIL_FIELDS], cwd);
+    const pull = JSON.parse(out);
+    // Fetch comments separately
+    const commentsOut = await gh(['pr', 'view', String(number), '--json', 'comments'], cwd);
+    const { comments: commentsList } = JSON.parse(commentsOut);
+    return {
+        ...pull,
+        comments_list: (commentsList || []).map((c) => ({
+            author: c.author,
+            body: c.body,
+            createdAt: c.createdAt,
+            updatedAt: c.updatedAt,
+        })),
+    };
+}
+export async function updateIssueState(cwd, number, action) {
+    if (action === 'close') {
+        await gh(['issue', 'close', String(number)], cwd);
+    }
+    else {
+        await gh(['issue', 'reopen', String(number)], cwd);
+    }
+}
+export async function updatePullState(cwd, number, action) {
+    if (action === 'close') {
+        await gh(['pr', 'close', String(number)], cwd);
+    }
+    else {
+        await gh(['pr', 'reopen', String(number)], cwd);
+    }
+}
+export async function createPullRequest(cwd, opts) {
+    const args = ['pr', 'create', '--title', opts.title];
+    if (opts.body)
+        args.push('--body', opts.body);
+    if (opts.base)
+        args.push('--base', opts.base);
+    const out = await gh(args, cwd);
+    // gh pr create outputs the PR URL on the last line
+    const url = out.trim().split('\n').pop() || '';
+    const numMatch = url.match(/\/pull\/(\d+)/);
+    return { number: numMatch ? parseInt(numMatch[1]) : 0, url };
+}

package/dist/src/services/obfuscation.d.ts

@@ -0,0 +1,2 @@
+export declare function obfuscate(plaintext: string): string;
+export declare function deobfuscate(encoded: string): string;

package/dist/src/services/obfuscation.js

@@ -0,0 +1,16 @@
+// Simple XOR + base64 obfuscation — NOT encryption, just prevents casual reading
+const XOR_KEY = 'atoo-studio-ssh-obfuscation-key-2024';
+export function obfuscate(plaintext) {
+    const buf = Buffer.from(plaintext, 'utf-8');
+    for (let i = 0; i < buf.length; i++) {
+        buf[i] ^= XOR_KEY.charCodeAt(i % XOR_KEY.length);
+    }
+    return buf.toString('base64');
+}
+export function deobfuscate(encoded) {
+    const buf = Buffer.from(encoded, 'base64');
+    for (let i = 0; i < buf.length; i++) {
+        buf[i] ^= XOR_KEY.charCodeAt(i % XOR_KEY.length);
+    }
+    return buf.toString('utf-8');
+}

package/dist/src/services/preview/headless-backend.d.ts

@@ -0,0 +1,62 @@
+import { Browser, Page, CDPSession } from 'puppeteer';
+import { PreviewBackend, PreviewInstanceBase, CreatePreviewOpts } from './preview-backend.js';
+export interface HeadlessInstance extends PreviewInstanceBase {
+    browser: Browser;
+    page: Page;
+    cdpSession: CDPSession;
+    browserCdpSession: CDPSession;
+    cdpPort: number;
+    screencastActive: boolean;
+    pendingAuthRequests: Map<string, {
+        requestId: string;
+        timeout: ReturnType<typeof setTimeout>;
+    }>;
+}
+export declare class HeadlessBackend implements PreviewBackend {
+    readonly mode: "headless";
+    private usedPorts;
+    cleanupOrphans(): void;
+    private allocateCdpPort;
+    private isPortFree;
+    private releaseCdpPort;
+    private startScreencast;
+    private stopScreencast;
+    private setupInterception;
+    private setupInjectedScripts;
+    private setupAuthInterception;
+    create(key: string, opts: CreatePreviewOpts): Promise<HeadlessInstance>;
+    destroy(instance: PreviewInstanceBase): Promise<void>;
+    private viewportTimers;
+    setViewport(instance: PreviewInstanceBase, viewport: {
+        width: number;
+        height: number;
+        dpr?: number;
+        isMobile?: boolean;
+        hasTouch?: boolean;
+    }): Promise<void>;
+    setQuality(instance: PreviewInstanceBase, quality: number): Promise<void>;
+    navigate(instance: PreviewInstanceBase, url: string): Promise<void>;
+    reload(instance: PreviewInstanceBase): Promise<void>;
+    dispatchMouseEvent(instance: PreviewInstanceBase, params: any): Promise<void>;
+    dispatchKeyEvent(instance: PreviewInstanceBase, params: any): Promise<void>;
+    insertText(instance: PreviewInstanceBase, text: string): Promise<void>;
+    dispatchScrollEvent(instance: PreviewInstanceBase, params: {
+        x: number;
+        y: number;
+        deltaX: number;
+        deltaY: number;
+    }): Promise<void>;
+    screenshot(instance: PreviewInstanceBase, fullPage?: boolean): Promise<string>;
+    handleDialogResponse(instance: PreviewInstanceBase, dialogId: string, accept: boolean, promptText?: string): void;
+    handleFileChooserResponse(instance: PreviewInstanceBase, backendNodeId: number, files: string[]): Promise<void>;
+    getDownloadPath(instance: PreviewInstanceBase, guid: string): string | null;
+    startRecording(instance: PreviewInstanceBase): void;
+    stopRecording(instance: PreviewInstanceBase): Promise<string>;
+    restartStream(instance: PreviewInstanceBase): Promise<void>;
+    handleSelectResponse(instance: PreviewInstanceBase, selectorPath: string, value: string): Promise<void>;
+    handlePickerResponse(instance: PreviewInstanceBase, selectorPath: string, value: string, inputType: string): Promise<void>;
+    handleAuthResponse(instance: PreviewInstanceBase, requestId: string, username: string, password: string): void;
+    handleAuthCancel(instance: PreviewInstanceBase, requestId: string): void;
+    handleContextMenuAction(instance: PreviewInstanceBase, action: string, params: any): Promise<void>;
+    shutdown(): Promise<void>;
+}