@playdrop/playdrop-cli 0.8.8 → 0.9.0

package/dist/commands/clients.js

@@ -0,0 +1,257 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showClientStatus = showClientStatus;
+exports.getClientStatus = getClientStatus;
+exports.installClient = installClient;
+exports.updateClient = updateClient;
+exports.launchClient = launchClient;
+exports.installMacDmg = installMacDmg;
+const node_fs_1 = require("node:fs");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = require("node:path");
+const node_child_process_1 = require("node:child_process");
+const output_1 = require("../output");
+const versionCompare_1 = require("../versionCompare");
+const MAC_APP_PATH = '/Applications/PlayDrop.app';
+const MAC_CLIENT_LATEST_URL = 'https://www.playdrop.ai/api/mac-client/latest';
+async function showClientStatus(options = {}) {
+    const status = await getClientStatus(options);
+    if (options.json) {
+        (0, output_1.printJson)(status);
+    }
+    else {
+        printClientStatus(status);
+    }
+    return status;
+}
+async function getClientStatus(options = {}) {
+    const platform = options.platform ?? process.platform;
+    if (platform !== 'darwin') {
+        return {
+            platform,
+            supported: false,
+            status: 'unavailable',
+            installed: false,
+            reason: `PlayDrop native clients are not available for ${platform}.`,
+        };
+    }
+    const appPath = options.appPath ?? MAC_APP_PATH;
+    const installed = (0, node_fs_1.existsSync)(appPath);
+    const bundle = installed ? readMacBundleInfo(appPath) : {};
+    const latest = await (options.fetchLatestManifest ?? fetchLatestMacClientManifest)();
+    const updateAvailable = Boolean(installed && (0, versionCompare_1.firstVersionIsNewer)(latest?.version, bundle.version));
+    return {
+        platform,
+        supported: true,
+        status: !installed ? 'missing' : updateAvailable ? 'update-available' : 'installed',
+        installed,
+        appPath,
+        version: bundle.version,
+        build: bundle.build,
+        latestVersion: latest?.version,
+        latestBuild: latest?.build,
+        updateAvailable,
+        nextAction: !installed ? 'playdrop clients install' : updateAvailable ? 'playdrop clients update' : undefined,
+    };
+}
+async function installClient(options = {}) {
+    await installOrUpdateClient('install', options);
+}
+async function updateClient(options = {}) {
+    await installOrUpdateClient('update', options);
+}
+async function launchClient(options = {}) {
+    const platform = options.platform ?? process.platform;
+    if (platform !== 'darwin') {
+        printUnsupportedPlatform(platform);
+        return;
+    }
+    const appPath = options.appPath ?? MAC_APP_PATH;
+    if (!(0, node_fs_1.existsSync)(appPath)) {
+        console.error(`PlayDrop is not installed at ${appPath}.`);
+        console.error('Run "playdrop clients install" first.');
+        process.exitCode = 1;
+        return;
+    }
+    const runCommand = options.runCommand ?? runCommandSync;
+    const result = runCommand('open', [appPath]);
+    if (result.status !== 0) {
+        console.error(`Failed to launch PlayDrop from ${appPath}.`);
+        process.exitCode = 1;
+        return;
+    }
+    console.log('Launched PlayDrop.');
+}
+async function installOrUpdateClient(action, options) {
+    const platform = options.platform ?? process.platform;
+    if (platform !== 'darwin') {
+        printUnsupportedPlatform(platform);
+        return;
+    }
+    const appPath = options.appPath ?? MAC_APP_PATH;
+    const runCommand = options.runCommand ?? runCommandSync;
+    if (isPlayDropRunning(runCommand)) {
+        console.error('PlayDrop is running. Quit PlayDrop before installing or updating.');
+        process.exitCode = 1;
+        return;
+    }
+    try {
+        (0, node_fs_1.accessSync)('/Applications', node_fs_1.constants.W_OK);
+    }
+    catch {
+        console.error('Cannot write to /Applications.');
+        console.error('Run this command from a terminal with permission to install apps into /Applications.');
+        process.exitCode = 1;
+        return;
+    }
+    const manifest = await (options.fetchLatestManifest ?? fetchLatestMacClientManifest)();
+    if (!manifest) {
+        console.error('Could not resolve the latest PlayDrop Mac client manifest.');
+        process.exitCode = 1;
+        return;
+    }
+    const installed = await installMacDmg(manifest, appPath, runCommand);
+    if (installed) {
+        console.log(`${action === 'install' ? 'Installed' : 'Updated'} PlayDrop at ${appPath}.`);
+    }
+}
+function printUnsupportedPlatform(platform) {
+    console.error(`PlayDrop native clients are not available for ${platform}.`);
+    process.exitCode = 1;
+}
+function printClientStatus(status) {
+    if (!status.supported) {
+        console.log(`PlayDrop client: unavailable on ${status.platform}`);
+        return;
+    }
+    if (!status.installed) {
+        console.log('PlayDrop client: missing');
+        console.log('Run: playdrop clients install');
+        return;
+    }
+    const version = status.version ? ` ${status.version}` : '';
+    console.log(`PlayDrop client: ${status.status}${version}`);
+    if (status.appPath) {
+        console.log(`Location: ${status.appPath}`);
+    }
+    if (status.updateAvailable) {
+        console.log('Run: playdrop clients update');
+    }
+}
+async function fetchLatestMacClientManifest() {
+    try {
+        const response = await fetch(MAC_CLIENT_LATEST_URL, { headers: { Accept: 'application/json' } });
+        if (!response.ok) {
+            return null;
+        }
+        const payload = await response.json();
+        if (payload.platform !== 'mac' || !payload.version || !payload.build || !payload.downloadUrl || !payload.dmgFilename) {
+            return null;
+        }
+        return {
+            platform: 'mac',
+            version: payload.version,
+            build: payload.build,
+            versionCode: payload.versionCode ?? payload.build,
+            filename: payload.filename ?? 'PlayDrop.app',
+            dmgFilename: payload.dmgFilename,
+            downloadUrl: payload.downloadUrl,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function readMacBundleInfo(appPath) {
+    const infoPath = (0, node_path_1.join)(appPath, 'Contents', 'Info.plist');
+    try {
+        const xml = (0, node_fs_1.readFileSync)(infoPath, 'utf8');
+        return {
+            version: readPlistString(xml, 'CFBundleShortVersionString'),
+            build: readPlistString(xml, 'CFBundleVersion'),
+        };
+    }
+    catch {
+        return {};
+    }
+}
+function readPlistString(xml, key) {
+    const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const match = xml.match(new RegExp(`<key>\\s*${escaped}\\s*</key>\\s*<string>([^<]+)</string>`));
+    return match?.[1]?.trim();
+}
+function isPlayDropRunning(runCommand) {
+    const result = (runCommand ?? runCommandSync)('pgrep', ['-x', 'PlayDrop']);
+    return result.status === 0;
+}
+async function installMacDmg(manifest, appPath, runCommand) {
+    const tempDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)(node_os_1.default.tmpdir(), 'playdrop-client-'));
+    const dmgPath = (0, node_path_1.join)(tempDir, (0, node_path_1.basename)(manifest.dmgFilename || 'PlayDrop.dmg'));
+    const mountPath = (0, node_path_1.join)(tempDir, 'mount');
+    (0, node_fs_1.mkdirSync)(mountPath, { recursive: true });
+    try {
+        const response = await fetch(manifest.downloadUrl);
+        if (!response.ok) {
+            throw new Error(`download_failed:${response.status}`);
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        (0, node_fs_1.writeFileSync)(dmgPath, Buffer.from(arrayBuffer));
+        const attach = runCommand('hdiutil', ['attach', dmgPath, '-nobrowse', '-quiet', '-mountpoint', mountPath]);
+        if (attach.status !== 0) {
+            throw new Error('hdiutil_attach_failed');
+        }
+        const sourceApp = (0, node_path_1.join)(mountPath, 'PlayDrop.app');
+        if (!(0, node_fs_1.existsSync)(sourceApp)) {
+            throw new Error('playdrop_app_missing_in_dmg');
+        }
+        replaceAppBundle(sourceApp, appPath);
+        return true;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Failed to install PlayDrop Mac client: ${message}`);
+        process.exitCode = 1;
+        return false;
+    }
+    finally {
+        runCommand('hdiutil', ['detach', mountPath, '-quiet']);
+        (0, node_fs_1.rmSync)(tempDir, { recursive: true, force: true });
+    }
+}
+function replaceAppBundle(sourceApp, appPath) {
+    const parentDirectory = (0, node_path_1.dirname)(appPath);
+    const appName = (0, node_path_1.basename)(appPath);
+    const uniqueSuffix = `${process.pid}-${Date.now()}`;
+    const stagedPath = (0, node_path_1.join)(parentDirectory, `.${appName}.installing-${uniqueSuffix}`);
+    const backupPath = (0, node_path_1.join)(parentDirectory, `.${appName}.previous-${uniqueSuffix}`);
+    let backupCreated = false;
+    try {
+        (0, node_fs_1.cpSync)(sourceApp, stagedPath, { recursive: true });
+        if ((0, node_fs_1.existsSync)(appPath)) {
+            (0, node_fs_1.renameSync)(appPath, backupPath);
+            backupCreated = true;
+        }
+        (0, node_fs_1.renameSync)(stagedPath, appPath);
+        if (backupCreated) {
+            (0, node_fs_1.rmSync)(backupPath, { recursive: true, force: true });
+        }
+    }
+    catch (error) {
+        (0, node_fs_1.rmSync)(stagedPath, { recursive: true, force: true });
+        if (backupCreated && !(0, node_fs_1.existsSync)(appPath) && (0, node_fs_1.existsSync)(backupPath)) {
+            (0, node_fs_1.renameSync)(backupPath, appPath);
+        }
+        throw error;
+    }
+}
+function runCommandSync(command, args) {
+    const result = (0, node_child_process_1.spawnSync)(command, args, { encoding: 'utf8' });
+    return {
+        status: result.status,
+        stdout: result.stdout ?? '',
+        stderr: result.stderr ?? '',
+    };
+}

package/dist/commands/doctor.d.ts

@@ -0,0 +1,51 @@
+import { type ClientStatus } from './clients';
+import { type AgentsStatus } from './agents';
+import { type WorkspaceCacheView } from './workspaces';
+interface ToolHealth {
+    installed: boolean;
+    version?: string;
+    path?: string;
+    identity?: string;
+}
+interface ToolsHealth {
+    node: ToolHealth;
+    npm: ToolHealth;
+    git: ToolHealth;
+}
+interface AccountHealth {
+    loggedIn: boolean;
+    identity?: string;
+}
+interface CliHealth {
+    version: string;
+    latestVersion?: string;
+    updateStatus: 'current' | 'update-available' | 'unknown';
+    updateAvailable?: boolean;
+    nextAction?: string;
+}
+export interface DoctorReport {
+    cli: CliHealth;
+    account: AccountHealth;
+    tools: ToolsHealth;
+    clients?: ClientStatus;
+    agents?: AgentsStatus;
+    workspaces?: ReturnType<typeof buildWorkspaceDoctorStatus>;
+    nextActions: string[];
+}
+interface DoctorProviders {
+    cli?: () => Promise<CliHealth>;
+    clients?: () => Promise<ClientStatus>;
+    agents?: () => Promise<AgentsStatus>;
+    workspaces?: () => Promise<ReturnType<typeof buildWorkspaceDoctorStatus>>;
+    tools?: () => Promise<ToolsHealth>;
+    account?: () => Promise<AccountHealth>;
+}
+interface DoctorOptions {
+    json?: boolean;
+    section?: string;
+    providers?: DoctorProviders;
+    cwd?: string;
+}
+export declare function showDoctor(options?: DoctorOptions): Promise<DoctorReport | null>;
+declare function buildWorkspaceDoctorStatus(cwd?: string): WorkspaceCacheView;
+export {};

package/dist/commands/doctor.js

@@ -0,0 +1,266 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showDoctor = showDoctor;
+const node_fs_1 = require("node:fs");
+const clientInfo_1 = require("../clientInfo");
+const config_1 = require("../config");
+const output_1 = require("../output");
+const shellProbe_1 = require("../shellProbe");
+const versionCompare_1 = require("../versionCompare");
+const clients_1 = require("./clients");
+const agents_1 = require("./agents");
+const workspaces_1 = require("./workspaces");
+async function showDoctor(options = {}) {
+    const section = normalizeSection(options.section);
+    if (options.section && !section) {
+        console.error(`Unknown doctor section "${options.section}". Expected clients, agents, or workspaces.`);
+        process.exitCode = 1;
+        return null;
+    }
+    const providers = options.providers ?? {};
+    const includeClients = !section || section === 'clients';
+    const includeAgents = !section || section === 'agents';
+    const includeWorkspaces = !section || section === 'workspaces';
+    const [cli, account, tools, clients, agents, workspaces] = await Promise.all([
+        providers.cli ? providers.cli() : getCliHealth(),
+        providers.account ? providers.account() : getAccountHealth(),
+        providers.tools ? providers.tools() : getToolsHealth(),
+        includeClients ? (providers.clients ? providers.clients() : (0, clients_1.getClientStatus)()) : Promise.resolve(undefined),
+        includeAgents ? (providers.agents ? providers.agents() : (0, agents_1.getAgentsStatus)()) : Promise.resolve(undefined),
+        includeWorkspaces ? (providers.workspaces ? providers.workspaces() : Promise.resolve(buildWorkspaceDoctorStatus(options.cwd))) : Promise.resolve(undefined),
+    ]);
+    const report = {
+        cli,
+        account,
+        tools,
+        clients,
+        agents,
+        workspaces,
+        nextActions: collectNextActions(cli, clients, agents, workspaces),
+    };
+    if (options.json) {
+        (0, output_1.printJson)(report);
+    }
+    else {
+        printDoctorReport(report);
+    }
+    return report;
+}
+function normalizeSection(value) {
+    if (!value) {
+        return null;
+    }
+    return value === 'clients' || value === 'agents' || value === 'workspaces' ? value : null;
+}
+async function getAccountHealth() {
+    const session = (0, config_1.getCurrentAccountSession)((0, config_1.loadConfig)());
+    if (!session) {
+        return { loggedIn: false };
+    }
+    return { loggedIn: true, identity: `${session.username} (${session.env})` };
+}
+async function getCliHealth() {
+    const currentVersion = (0, clientInfo_1.getCliVersion)();
+    const result = (0, shellProbe_1.runShell)('npm view @playdrop/playdrop-cli version --json');
+    if (result.exitCode !== 0 || !result.output.trim()) {
+        return {
+            version: (0, clientInfo_1.getCliVersionLabel)(),
+            updateStatus: 'unknown',
+        };
+    }
+    const latestVersion = parseNpmVersion(result.output);
+    if (!latestVersion) {
+        return {
+            version: (0, clientInfo_1.getCliVersionLabel)(),
+            updateStatus: 'unknown',
+        };
+    }
+    const updateAvailable = (0, versionCompare_1.firstVersionIsNewer)(latestVersion, currentVersion);
+    return {
+        version: (0, clientInfo_1.getCliVersionLabel)(),
+        latestVersion,
+        updateStatus: updateAvailable ? 'update-available' : 'current',
+        updateAvailable,
+        nextAction: updateAvailable ? 'playdrop update' : undefined,
+    };
+}
+function parseNpmVersion(output) {
+    const trimmed = output.trim();
+    try {
+        const parsed = JSON.parse(trimmed);
+        return typeof parsed === 'string' && parsed.trim().length > 0 ? parsed.trim() : undefined;
+    }
+    catch {
+        return trimmed.length > 0 ? trimmed.split('\n')[0]?.trim() : undefined;
+    }
+}
+async function getToolsHealth() {
+    const [node, npm, git] = await Promise.all([
+        detectTool('node', ['--version']),
+        detectTool('npm', ['--version']),
+        detectGit(),
+    ]);
+    return { node, npm, git };
+}
+async function detectTool(command, versionArgs) {
+    const pathProbe = (0, shellProbe_1.runShell)((0, shellProbe_1.buildCommandPathProbe)(command));
+    if (pathProbe.exitCode !== 0 || !pathProbe.output) {
+        return { installed: false };
+    }
+    const version = (0, shellProbe_1.runShell)([command, ...versionArgs].join(' '));
+    return {
+        installed: true,
+        path: pathProbe.output.split('\n')[0]?.trim(),
+        version: version.exitCode === 0 ? version.output.split('\n')[0]?.trim() : undefined,
+    };
+}
+async function detectGit() {
+    const status = await detectTool('git', ['--version']);
+    if (!status.installed) {
+        return status;
+    }
+    const email = (0, shellProbe_1.runShell)('git config --global --get user.email').output.trim();
+    const name = (0, shellProbe_1.runShell)('git config --global --get user.name').output.trim();
+    const identity = email ? (name ? `${name} <${email}>` : email) : name || undefined;
+    return { ...status, identity };
+}
+function buildWorkspaceDoctorStatus(cwd) {
+    const cache = (0, workspaces_1.loadWorkspaceCacheWithCurrentContext)({ cwd });
+    return {
+        ...cache,
+        defaultWorkspacePath: cache.defaultWorkspacePath,
+        workspaces: cache.workspaces.map((workspace) => ({
+            ...workspace,
+            exists: (0, node_fs_1.existsSync)(workspace.path),
+        })),
+    };
+}
+function collectNextActions(cli, clients, agents, workspaces) {
+    const actions = [];
+    if (cli.nextAction) {
+        actions.push(cli.nextAction);
+    }
+    if (clients?.nextAction) {
+        actions.push(clients.nextAction);
+    }
+    for (const agent of agents?.agents ?? []) {
+        if (agent.nextAction?.command) {
+            actions.push(agent.nextAction.command);
+        }
+    }
+    if (workspaces && workspaces.workspaces.length === 0) {
+        actions.push(recommendedWorkspaceRefreshCommand());
+        actions.push('playdrop workspaces init');
+    }
+    return [...new Set(actions)];
+}
+function recommendedWorkspaceRefreshCommand() {
+    return (0, workspaces_1.getWorkspaceRefreshExample)();
+}
+function printDoctorReport(report) {
+    const cliUpdate = report.cli.updateStatus === 'update-available'
+        ? `, update available: ${report.cli.latestVersion}`
+        : report.cli.updateStatus === 'current'
+            ? ', current'
+            : ', update status unknown';
+    console.log(`PlayDrop CLI: ${report.cli.version}${cliUpdate}`);
+    console.log(`Account: ${report.account.loggedIn ? report.account.identity ?? 'logged in' : 'not logged in'}`);
+    console.log(`Node: ${report.tools.node.installed ? report.tools.node.version ?? 'installed' : 'missing'}`);
+    console.log(`npm: ${report.tools.npm.installed ? report.tools.npm.version ?? 'installed' : 'missing'}`);
+    console.log(`Git: ${report.tools.git.installed ? report.tools.git.identity ?? report.tools.git.version ?? 'installed' : 'missing'}`);
+    if (report.clients) {
+        printNativeClientDoctorStatus(report.clients);
+    }
+    if (report.agents) {
+        printAgentsDoctorStatus(report.agents);
+    }
+    if (report.workspaces) {
+        if (report.workspaces.workspaces.length === 0) {
+            (0, workspaces_1.printNoCachedWorkspacesGuidance)(report.workspaces.defaultWorkspacePath);
+        }
+        else {
+            console.log(`Cached workspaces: ${report.workspaces.workspaces.length}`);
+            if (report.workspaces.currentWorkspacePath) {
+                console.log(`Current workspace: ${report.workspaces.currentWorkspacePath}`);
+            }
+        }
+    }
+    if (report.nextActions.length > 0) {
+        console.log('Next actions:');
+        for (const action of report.nextActions) {
+            console.log(`  Run: ${action}`);
+        }
+    }
+}
+function printNativeClientDoctorStatus(status) {
+    if (!status.supported) {
+        console.log(`Native client: unavailable on ${status.platform}`);
+        return;
+    }
+    if (!status.installed) {
+        console.log('Native client: missing');
+        return;
+    }
+    const statusLabel = status.updateAvailable ? 'update available' : 'up to date';
+    console.log(`Native client: ${statusLabel}`);
+    console.log(`  Installed: ${formatVersionBuild(status.version, status.build)}`);
+    if (status.latestVersion || status.latestBuild) {
+        console.log(`  Latest: ${formatVersionBuild(status.latestVersion, status.latestBuild)}`);
+    }
+    if (status.appPath) {
+        console.log(`  Location: ${status.appPath}`);
+    }
+}
+function printAgentsDoctorStatus(status) {
+    console.log('Agents:');
+    if (status.agents.length === 0) {
+        console.log('  none detected');
+        return;
+    }
+    for (const agent of status.agents) {
+        console.log(`  ${agent.name}`);
+        console.log(`    App: ${agent.app.installed ? agent.app.path ? `installed at ${agent.app.path}` : 'installed' : 'missing'}`);
+        console.log(`    CLI: ${formatAgentCli(agent.cli)}`);
+        console.log(`    Account: ${formatAgentAccount(agent.account)}`);
+        console.log(`    Plugin: ${formatAgentPlugin(agent.plugin)}`);
+    }
+}
+function formatVersionBuild(version, build) {
+    if (version && build) {
+        return `${version} (build ${build})`;
+    }
+    return version ?? build ?? 'unknown';
+}
+function formatAgentCli(cli) {
+    if (!cli.installed) {
+        return 'missing';
+    }
+    const label = cli.version ?? 'installed';
+    return cli.path ? `${label} at ${cli.path}` : label;
+}
+function formatAgentAccount(account) {
+    if (account?.identity) {
+        return account.subscription ? `${account.identity} (${account.subscription})` : account.identity;
+    }
+    if (account?.signedIn === false) {
+        return 'not signed in';
+    }
+    return 'unknown';
+}
+function formatAgentPlugin(plugin) {
+    if (plugin.status === 'manual-verification-required') {
+        return plugin.latestVersion ? `manual verification required, latest: ${plugin.latestVersion}` : 'manual verification required';
+    }
+    if (plugin.status === 'unknown') {
+        return plugin.message ? `unknown (${plugin.message})` : 'unknown';
+    }
+    if (!plugin.installed) {
+        return plugin.latestVersion ? `missing, latest: ${plugin.latestVersion}` : 'missing';
+    }
+    const installedVersion = plugin.version ?? 'installed';
+    const enabled = plugin.status === 'activation-required' || plugin.enabled === false ? ', activation required' : '';
+    if (plugin.updateAvailable) {
+        return `${installedVersion}${enabled}, update available: ${plugin.latestVersion ?? 'unknown'}`;
+    }
+    return `${installedVersion}${enabled}, up to date`;
+}