waitspin 0.1.13 → 0.1.14

package/dist/cli.js

@@ -84,8 +84,44 @@ const QODER_HOOK_TIMEOUT_SECONDS = 15;
 const QODER_HOOK_STATUS_MESSAGE = "WaitSpin sponsor check";
 const QODER_HOOK_EVENTS = ["UserPromptSubmit", "Stop"];
 const QODER_ACCEPTANCE_HINT = "Run a real Qoder TUI prompt and keep the sponsored system message visible for at least 5 seconds. WaitSpin schedules a delayed visibility check after display; Stop or next-prompt hooks refresh the same managed state.";
+const WAITSPIN_EDITOR_EXTENSION_ID = "waitspin.waitspin-vscode";
+const EDITOR_PUBLISHER_TARGET = "status-bar-fallback";
 const extensionTargets = {
-    vscode: "vscode",
+    vscode: {
+        label: "VS Code",
+        mode: "bundled",
+        publisherTarget: EDITOR_PUBLISHER_TARGET,
+    },
+    cursor: {
+        label: "Cursor",
+        mode: "editor-cli",
+        publisherTarget: EDITOR_PUBLISHER_TARGET,
+        registryLabel: "VS Code Marketplace",
+        registryUrl: "https://marketplace.visualstudio.com/items?itemName=waitspin.waitspin-vscode",
+        binaryEnv: "WAITSPIN_CURSOR_EDITOR_BIN",
+        defaultBinary: "cursor",
+        windowsDefaultBinaries: ["cursor"],
+        windowsRelativeBinaries: [["Programs", "cursor", "Cursor.exe"]],
+        productMarker: "cursor",
+        executableBasenames: ["cursor", "cursor-editor"],
+        macosAppBinary: "/Applications/Cursor.app/Contents/Resources/app/bin/cursor",
+        macosUserAppBinary: path.join(os.homedir(), "Applications", "Cursor.app", "Contents", "Resources", "app", "bin", "cursor"),
+    },
+    devin: {
+        label: "Devin Desktop",
+        mode: "editor-cli",
+        publisherTarget: EDITOR_PUBLISHER_TARGET,
+        registryLabel: "Open VSX",
+        registryUrl: "https://open-vsx.org/extension/waitspin/waitspin-vscode",
+        binaryEnv: "WAITSPIN_DEVIN_DESKTOP_BIN",
+        defaultBinary: "devin-desktop",
+        windowsDefaultBinaries: ["devin", "devin-desktop"],
+        windowsRelativeBinaries: [["devin", "bin", "devin.exe"]],
+        productMarker: "devin",
+        executableBasenames: ["devin", "devin-desktop"],
+        macosAppBinary: "/Applications/Devin.app/Contents/Resources/app/bin/devin-desktop",
+        macosUserAppBinary: path.join(os.homedir(), "Applications", "Devin.app", "Contents", "Resources", "app", "bin", "devin-desktop"),
+    },
 };
 export function usageText() {
     return ([
@@ -100,9 +136,9 @@ export function usageText() {
         "  waitspin wallet ledger [--limit N] [--json] [--base-url URL] [--api-key KEY]",
         "  waitspin wallet payout --dry-run [--json] [--base-url URL] [--api-key KEY]",
         "  waitspin wallet payout --confirm-test-transfer [--json] [--base-url URL] [--api-key KEY]",
-        "  waitspin extension install [--target vscode] [--json] [--base-url URL] [--api-key KEY] [--dry-run]",
-        "  waitspin extension status [--target vscode] [--json]",
-        "  waitspin extension uninstall [--target vscode] [--json] [--dry-run]",
+        "  waitspin extension install [--target vscode|cursor|devin] [--json] [--base-url URL] [--api-key KEY] [--dry-run]",
+        "  waitspin extension status [--target vscode|cursor|devin] [--json]",
+        "  waitspin extension uninstall [--target vscode|cursor|devin] [--json] [--dry-run]",
         "  waitspin install --all [--json] [--api-key KEY] [--compose-existing] [--dry-run]",
         "  waitspin status --all [--json] [--demo]",
         "  waitspin claude-code install [--json] [--api-key KEY] [--compose-existing] [--dry-run]",
@@ -730,7 +766,377 @@ export function generateInstallId() {
     return `wins_${randomUUID().replace(/-/g, "")}`;
 }
 export function publisherTargetForExtension(target) {
-    return target === "vscode" ? "status-bar-fallback" : target;
+    return extensionTargets[target].publisherTarget;
+}
+function isEditorCliExtensionTarget(target) {
+    return extensionTargets[target].mode === "editor-cli";
+}
+const EDITOR_PROCESS_ENV_KEYS = [
+    "APPDATA",
+    "COLORTERM",
+    "COMSPEC",
+    "HOME",
+    "LANG",
+    "LC_ALL",
+    "LC_CTYPE",
+    "LOCALAPPDATA",
+    "LOGNAME",
+    "NODE_EXTRA_CA_CERTS",
+    "NO_PROXY",
+    "PATH",
+    "PATHEXT",
+    "SHELL",
+    "SSL_CERT_DIR",
+    "SSL_CERT_FILE",
+    "SystemRoot",
+    "TEMP",
+    "TERM",
+    "TMP",
+    "TMPDIR",
+    "USER",
+    "USERPROFILE",
+    "XDG_CACHE_HOME",
+    "XDG_CONFIG_HOME",
+    "XDG_DATA_HOME",
+];
+function editorProxyEnvValue(value) {
+    if (!value)
+        return undefined;
+    try {
+        const url = new URL(value);
+        if (!["http:", "https:"].includes(url.protocol) ||
+            url.username ||
+            url.password ||
+            url.search ||
+            url.hash) {
+            return undefined;
+        }
+        return value;
+    }
+    catch {
+        return undefined;
+    }
+}
+function editorProcessEnv() {
+    const env = { NODE_ENV: process.env.NODE_ENV };
+    for (const key of EDITOR_PROCESS_ENV_KEYS) {
+        const value = process.env[key];
+        if (value !== undefined)
+            env[key] = value;
+    }
+    for (const key of ["HTTP_PROXY", "HTTPS_PROXY"]) {
+        const value = editorProxyEnvValue(process.env[key]);
+        if (value !== undefined)
+            env[key] = value;
+    }
+    return env;
+}
+function editorExecOptions(timeout) {
+    return { encoding: "utf8", timeout, env: editorProcessEnv() };
+}
+function uniqueNonEmpty(values) {
+    return Array.from(new Set(values.map((value) => value?.trim()).filter(Boolean)));
+}
+function editorCliCandidates(target) {
+    const descriptor = extensionTargets[target];
+    const localAppData = process.env.LOCALAPPDATA?.trim();
+    const windowsCandidates = process.platform === "win32"
+        ? [
+            ...descriptor.windowsDefaultBinaries,
+            ...(localAppData
+                ? descriptor.windowsRelativeBinaries.map((segments) => path.win32.join(localAppData, ...segments))
+                : []),
+        ]
+        : [];
+    return uniqueNonEmpty([
+        process.env[descriptor.binaryEnv],
+        ...(process.platform === "win32"
+            ? windowsCandidates
+            : [descriptor.defaultBinary]),
+        ...(process.platform === "darwin"
+            ? [descriptor.macosAppBinary, descriptor.macosUserAppBinary]
+            : []),
+    ]);
+}
+function isWindowsEditorCommandScript(binary) {
+    return process.platform === "win32" && /\.(?:cmd|bat)$/i.test(binary);
+}
+function assertSafeWindowsEditorCommandScript(binary) {
+    if (/["\r\n\u0000%&|<>^!]/.test(binary)) {
+        throw new Error("Refusing unsafe Windows editor command shim path.");
+    }
+}
+async function resolveWindowsEditorCommand(binary) {
+    if (process.platform !== "win32")
+        return binary;
+    if (path.win32.isAbsolute(binary) ||
+        binary.includes("\\") ||
+        binary.includes("/") ||
+        path.win32.extname(binary)) {
+        return binary;
+    }
+    const result = await execFileText("where.exe", [binary], editorExecOptions(5_000)).catch(() => null);
+    if (!result)
+        return binary;
+    return (result.stdout
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find((line) => path.win32.isAbsolute(line) &&
+        /\.(?:exe|com|cmd|bat)$/i.test(path.win32.extname(line))) || binary);
+}
+async function editorCommandForBinary(binary) {
+    const resolvedBinary = await resolveWindowsEditorCommand(binary);
+    if (!isWindowsEditorCommandScript(resolvedBinary)) {
+        return {
+            binary: resolvedBinary,
+            executable: resolvedBinary,
+            argumentPrefix: [],
+        };
+    }
+    assertSafeWindowsEditorCommandScript(resolvedBinary);
+    return {
+        binary: resolvedBinary,
+        executable: process.env.ComSpec || "cmd.exe",
+        argumentPrefix: [
+            "/d",
+            "/v:off",
+            "/s",
+            "/c",
+            "call",
+            resolvedBinary,
+        ],
+    };
+}
+function execEditorCommand(editor, args, timeout) {
+    return execFileText(editor.executable, [...editor.argumentPrefix, ...args], editorExecOptions(timeout));
+}
+function editorCliMatchesProduct(target, binary, version, help) {
+    const descriptor = extensionTargets[target];
+    const identityText = `${version}\n${help}`.toLowerCase();
+    if (identityText.includes(descriptor.productMarker))
+        return true;
+    const knownOtherProduct = ["cursor", "devin", "visual studio code"].some((marker) => marker !== descriptor.productMarker && identityText.includes(marker));
+    if (knownOtherProduct)
+        return false;
+    const basename = path.basename(binary).toLowerCase().replace(/\.(exe|cmd|bat)$/, "");
+    return descriptor.executableBasenames.includes(basename);
+}
+async function resolveEditorCli(target) {
+    const descriptor = extensionTargets[target];
+    let lastError;
+    for (const binary of editorCliCandidates(target)) {
+        try {
+            const editor = await editorCommandForBinary(binary);
+            const result = await execEditorCommand(editor, ["--version"], 5_000);
+            const helpResult = await execEditorCommand(editor, ["--help"], 5_000);
+            const help = `${helpResult.stdout}\n${helpResult.stderr}`;
+            if (![
+                "--install-extension",
+                "--list-extensions",
+                "--uninstall-extension",
+            ].every((option) => help.includes(option))) {
+                lastError = new Error(`${binary} does not expose editor extension management.`);
+                continue;
+            }
+            const version = `${result.stdout || result.stderr || descriptor.label}`.trim();
+            if (!editorCliMatchesProduct(target, editor.binary, version, help)) {
+                lastError = new Error(`${editor.binary} does not identify as ${descriptor.label}.`);
+                continue;
+            }
+            return {
+                ...editor,
+                version,
+            };
+        }
+        catch (error) {
+            lastError = error;
+        }
+    }
+    throw new Error(`${descriptor.label} was not detected. Install ${descriptor.label}, add ${process.platform === "win32" ? descriptor.windowsDefaultBinaries[0] : descriptor.defaultBinary} to PATH, or set ${descriptor.binaryEnv} to the editor executable path.`, { cause: lastError });
+}
+function parseEditorExtensionStatus(output) {
+    for (const rawLine of output.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        const match = /^waitspin\.waitspin-vscode(?:@([^\s]+))?$/i.exec(line);
+        if (match) {
+            return { installed: true, version: match[1] || null };
+        }
+    }
+    return { installed: false, version: null };
+}
+async function readEditorExtensionStatus(editor) {
+    const result = await execEditorCommand(editor, ["--list-extensions", "--show-versions"], 10_000);
+    return parseEditorExtensionStatus(`${result.stdout}\n${result.stderr}`);
+}
+function editorActivationCommand(target) {
+    return `WaitSpin: Connect and earn inside ${extensionTargets[target].label}`;
+}
+async function runEditorExtensionInstall(target, flags) {
+    const descriptor = extensionTargets[target];
+    const editor = await resolveEditorCli(target);
+    const before = await readEditorExtensionStatus(editor);
+    const summary = {
+        ok: true,
+        target,
+        mode: EDITOR_PUBLISHER_TARGET,
+        detected: true,
+        editor: descriptor.label,
+        editor_version: editor.version,
+        editor_binary: editor.binary,
+        extension: WAITSPIN_EDITOR_EXTENSION_ID,
+        version: before.version,
+        installed: before.installed,
+        registry: descriptor.registryLabel,
+        registry_url: descriptor.registryUrl,
+        publisher_target: descriptor.publisherTarget,
+        publisher_registration_managed_by: "editor-extension",
+        activation_required: true,
+        next: { command: editorActivationCommand(target) },
+        next_command: editorActivationCommand(target),
+    };
+    if (booleanFlag(flags, "dry-run")) {
+        const dryRunPayload = {
+            ...summary,
+            dry_run: true,
+            planned_argv: [
+                editor.binary,
+                "--install-extension",
+                WAITSPIN_EDITOR_EXTENSION_ID,
+                "--force",
+            ],
+        };
+        printCliOutput(flags, dryRunPayload, formatTargetInstallResult(dryRunPayload));
+        return;
+    }
+    await execEditorCommand(editor, ["--install-extension", WAITSPIN_EDITOR_EXTENSION_ID, "--force"], 30_000);
+    const after = await readEditorExtensionStatus(editor);
+    if (!after.installed) {
+        throw new Error(`${descriptor.label} did not report ${WAITSPIN_EDITOR_EXTENSION_ID} after installation.`);
+    }
+    const output = {
+        ...summary,
+        installed: true,
+        version: after.version,
+    };
+    printCliOutput(flags, output, formatTargetInstallResult(output));
+}
+async function runEditorExtensionStatus(target, flags) {
+    const descriptor = extensionTargets[target];
+    let editor;
+    try {
+        editor = await resolveEditorCli(target);
+    }
+    catch (error) {
+        const output = {
+            ok: true,
+            target,
+            mode: EDITOR_PUBLISHER_TARGET,
+            detected: false,
+            installed: false,
+            version: null,
+            publisher_target: descriptor.publisherTarget,
+            publisher_registration_managed_by: "editor-extension",
+            activation_required: false,
+            detection_error: redactCliSecretText(error instanceof Error ? error.message : String(error)),
+            next: {
+                command: `waitspin extension install --target ${target}`,
+            },
+            next_command: `waitspin extension install --target ${target}`,
+        };
+        printCliOutput(flags, output, formatTargetStatusResult(output));
+        return;
+    }
+    const status = await readEditorExtensionStatus(editor);
+    const output = {
+        ok: true,
+        target,
+        mode: EDITOR_PUBLISHER_TARGET,
+        detected: true,
+        editor: descriptor.label,
+        editor_version: editor.version,
+        editor_binary: editor.binary,
+        extension: WAITSPIN_EDITOR_EXTENSION_ID,
+        version: status.version,
+        installed: status.installed,
+        publisher_target: descriptor.publisherTarget,
+        publisher_registration_managed_by: "editor-extension",
+        activation_required: status.installed,
+        next: status.installed
+            ? { command: editorActivationCommand(target) }
+            : {
+                command: `waitspin extension install --target ${target}`,
+            },
+        next_command: status.installed
+            ? editorActivationCommand(target)
+            : `waitspin extension install --target ${target}`,
+    };
+    printCliOutput(flags, output, formatTargetStatusResult(output));
+}
+async function runEditorExtensionUninstall(target, flags) {
+    const descriptor = extensionTargets[target];
+    let editor;
+    try {
+        editor = await resolveEditorCli(target);
+    }
+    catch (error) {
+        const output = {
+            ok: true,
+            target,
+            detected: false,
+            installed: false,
+            uninstalled: false,
+            dry_run: booleanFlag(flags, "dry-run"),
+            publisher_target: descriptor.publisherTarget,
+            detection_error: redactCliSecretText(error instanceof Error ? error.message : String(error)),
+        };
+        printCliOutput(flags, output, formatTargetUninstallResult(output));
+        return;
+    }
+    const before = await readEditorExtensionStatus(editor);
+    const summary = {
+        ok: true,
+        target,
+        detected: true,
+        installed: before.installed,
+        version: before.version,
+        extension: WAITSPIN_EDITOR_EXTENSION_ID,
+        publisher_target: descriptor.publisherTarget,
+    };
+    if (booleanFlag(flags, "dry-run")) {
+        const output = {
+            ...summary,
+            dry_run: true,
+            planned_argv: before.installed
+                ? [
+                    editor.binary,
+                    "--uninstall-extension",
+                    WAITSPIN_EDITOR_EXTENSION_ID,
+                ]
+                : null,
+            would_remove_extension: before.installed
+                ? WAITSPIN_EDITOR_EXTENSION_ID
+                : null,
+        };
+        printCliOutput(flags, output, formatTargetUninstallResult(output));
+        return;
+    }
+    if (!before.installed) {
+        const output = { ...summary, uninstalled: false };
+        printCliOutput(flags, output, formatTargetUninstallResult(output));
+        return;
+    }
+    await execEditorCommand(editor, ["--uninstall-extension", WAITSPIN_EDITOR_EXTENSION_ID], 30_000);
+    const after = await readEditorExtensionStatus(editor);
+    if (after.installed) {
+        throw new Error(`${descriptor.label} still reports ${WAITSPIN_EDITOR_EXTENSION_ID} after uninstall.`);
+    }
+    const output = {
+        ...summary,
+        installed: false,
+        uninstalled: true,
+        removed_extension: WAITSPIN_EDITOR_EXTENSION_ID,
+    };
+    printCliOutput(flags, output, formatTargetUninstallResult(output));
 }
 function extensionInstallDir(_target) {
     return path.join(os.homedir(), ".vscode", "extensions");
@@ -755,8 +1161,8 @@ function extensionMarkerPath(target) {
 }
 function resolveExtensionTarget(flags) {
     const target = optionalFlag(flags, "target") || "vscode";
-    if (!(target in extensionTargets)) {
-        throw new Error(`Unsupported extension target: ${target}. Public WaitSpin installs currently support --target vscode only.`);
+    if (!Object.prototype.hasOwnProperty.call(extensionTargets, target)) {
+        throw new Error(`Unsupported extension target: ${target}. Public WaitSpin installs support --target vscode, cursor, or devin.`);
     }
     return target;
 }
@@ -986,6 +1392,10 @@ async function validateVscodeExtensionRuntimeSource(sourceDir) {
 }
 export async function runExtensionInstall(flags) {
     const target = resolveExtensionTarget(flags);
+    if (isEditorCliExtensionTarget(target)) {
+        await runEditorExtensionInstall(target, flags);
+        return;
+    }
     const baseUrl = resolveCredentialedBaseUrl(flags);
     const publisherTarget = publisherTargetForExtension(target);
     const extensionDir = await resolveExtensionDir(flags);
@@ -1094,6 +1504,10 @@ function managedInstalledPathStatus(marker) {
 }
 export async function runExtensionStatus(flags) {
     const target = resolveExtensionTarget(flags);
+    if (isEditorCliExtensionTarget(target)) {
+        await runEditorExtensionStatus(target, flags);
+        return;
+    }
     const statePath = installStatePath(target);
     const markerPath = extensionMarkerPath(target);
     const [state, marker] = await Promise.all([
@@ -1127,6 +1541,10 @@ export async function runExtensionStatus(flags) {
 }
 export async function runExtensionUninstall(flags) {
     const target = resolveExtensionTarget(flags);
+    if (isEditorCliExtensionTarget(target)) {
+        await runEditorExtensionUninstall(target, flags);
+        return;
+    }
     const statePath = installStatePath(target);
     const markerPath = extensionMarkerPath(target);
     const marker = await loadInstallMarker(markerPath);
@@ -5981,9 +6399,9 @@ function jsonFlags(flags) {
     next.set("json", ["true"]);
     return next;
 }
-function extensionAllFlags(flags) {
+function extensionAllFlags(flags, target) {
     const next = cloneFlags(flags);
-    next.set("target", ["vscode"]);
+    next.set("target", [target]);
     return next;
 }
 function executableFromEnv(envName, defaultBin) {
@@ -6005,6 +6423,10 @@ async function executableVersion(envName, defaultBin, label) {
 async function preflightVscode(flags) {
     return resolveExtensionDir(flags);
 }
+async function preflightEditorExtension(target) {
+    const editor = await resolveEditorCli(target);
+    return `${extensionTargets[target].label} ${editor.version} (${editor.binary})`;
+}
 async function preflightClaudeCode() {
     return assertSupportedClaudeCodeVersion();
 }
@@ -6043,8 +6465,24 @@ function allInstallTargets(flags) {
             command: "waitspin extension install --target vscode",
             statusCommand: "waitspin extension status --target vscode",
             preflight: preflightVscode,
-            install: (flags) => runExtensionInstall(extensionAllFlags(flags)),
-            status: (flags) => runExtensionStatus(extensionAllFlags(flags)),
+            install: (flags) => runExtensionInstall(extensionAllFlags(flags, "vscode")),
+            status: (flags) => runExtensionStatus(extensionAllFlags(flags, "vscode")),
+        },
+        {
+            target: "cursor",
+            command: "waitspin extension install --target cursor",
+            statusCommand: "waitspin extension status --target cursor",
+            preflight: () => preflightEditorExtension("cursor"),
+            install: (flags) => runExtensionInstall(extensionAllFlags(flags, "cursor")),
+            status: (flags) => runExtensionStatus(extensionAllFlags(flags, "cursor")),
+        },
+        {
+            target: "devin",
+            command: "waitspin extension install --target devin",
+            statusCommand: "waitspin extension status --target devin",
+            preflight: () => preflightEditorExtension("devin"),
+            install: (flags) => runExtensionInstall(extensionAllFlags(flags, "devin")),
+            status: (flags) => runExtensionStatus(extensionAllFlags(flags, "devin")),
         },
         {
             target: CLAUDE_CODE_PUBLISHER_TARGET,