@libai168/dsh-tool-google-drive 0.2.0

package/lib/index.js

@@ -0,0 +1,339 @@
+import { defineTool } from '@deepseek-ai/dsh-tools';
+import { GoogleDriveClient, GoogleDriveError } from './client.js';
+export const name = 'dsh-tool-google-drive';
+export const inject = ['tools'];
+export function apply(ctx, config = {}) {
+    const client = new GoogleDriveClient(config);
+    for (const tool of createTools(client))
+        ctx.tools.register(tool);
+}
+function unavailable(reason) {
+    return { found: false, reason };
+}
+function text(value) {
+    return [{ type: 'text', text: value }];
+}
+function fileProperties() {
+    return {
+        id: { type: 'string' }, name: { type: 'string' }, mimeType: { type: 'string' }, kind: { type: 'string' },
+        description: { type: 'string' }, iconLink: { type: 'string' }, webViewLink: { type: 'string' }, webContentLink: { type: 'string' },
+        size: { type: 'string' }, starred: { type: 'boolean' }, trashed: { type: 'boolean' }, modifiedTime: { type: 'string' },
+        createdTime: { type: 'string' }, driveId: { type: 'string' }, parents: { type: 'array', items: { type: 'string' } },
+        owners: { type: 'array', items: { type: 'object', additionalProperties: false, properties: {
+                    displayName: { type: 'string' }, emailAddress: { type: 'string' },
+                } } },
+    };
+}
+function driveProperties() {
+    return {
+        id: { type: 'string' }, name: { type: 'string' }, colorRgb: { type: 'string' }, backgroundImageLink: { type: 'string' },
+        createdTime: { type: 'string' }, hidden: { type: 'boolean' }, themeId: { type: 'string' },
+        capabilities: { type: 'string' }, restrictions: { type: 'string' },
+    };
+}
+function renderFiles(items) {
+    if (!items.length)
+        return text('No Google Drive files found.');
+    return text(items.map(file => `${file.name ?? ''} (${file.id ?? ''}) ${file.mimeType ?? ''} ${file.modifiedTime ?? ''}`).join('\n'));
+}
+function renderFile(file) {
+    return text([
+        `${file.name ?? ''} (${file.id ?? ''})`,
+        `mimeType=${file.mimeType ?? ''}`,
+        `modified=${file.modifiedTime ?? ''}`,
+        `link=${file.webViewLink ?? ''}`,
+        file.description ? `description=${file.description}` : '',
+    ].filter(Boolean).join('\n'));
+}
+function renderPermissions(items) {
+    if (!items.length)
+        return text('No Google Drive permissions found.');
+    return text(items.map(permission => {
+        const subject = permission.displayName || permission.emailAddress || permission.id || '';
+        return subject + ' (' + (permission.type ?? '') + ') role=' + (permission.role ?? '') + (permission.deleted ? ' deleted' : '');
+    }).join('\\n'));
+}
+function renderRevisions(items) {
+    if (!items.length)
+        return text('No Google Drive revisions found.');
+    return text(items.map(revision => [
+        revision.id ?? '', revision.modifiedTime ?? '', revision.mimeType ? 'mimeType=' + revision.mimeType : '',
+        revision.size ? 'size=' + revision.size : '', revision.keepForever ? 'keepForever' : '', revision.published ? 'published' : '',
+    ].filter(Boolean).join(' ')).join('\\n'));
+}
+function renderDrives(items) {
+    if (!items.length)
+        return text('No shared drives found.');
+    return text(items.map(drive => `${drive.name ?? ''} (${drive.id ?? ''}) ${drive.createdTime ?? ''}`).join('\n'));
+}
+function renderDocument(doc) {
+    return text([
+        `${doc.title ?? ''} (${doc.documentId ?? ''})`,
+        `revision=${doc.revisionId ?? ''} tabs=${doc.tabCount ?? 0}`,
+        (doc.text ?? '').slice(0, 4000),
+    ].filter(Boolean).join('\n'));
+}
+function renderSpreadsheet(sheet) {
+    const tabs = (sheet.sheets ?? []).map(s => `${s.title ?? ''} ${s.rowCount ?? 0}x${s.columnCount ?? 0}`).join('\n');
+    return text([
+        `${sheet.title ?? ''} (${sheet.spreadsheetId ?? ''})`,
+        `sheets=${sheet.sheetCount ?? 0}`,
+        `url=${sheet.spreadsheetUrl ?? ''}`,
+        tabs,
+    ].filter(Boolean).join('\n'));
+}
+function renderValues(value) {
+    const rows = (value.values ?? []).slice(0, 20).map(row => row.join('\t')).join('\n');
+    return text([`${value.range ?? ''} rows=${value.rowCount ?? 0} columns=${value.columnCount ?? 0}`, rows].filter(Boolean).join('\n'));
+}
+export function createTools(client) {
+    return [
+        defineTool({
+            name: 'gdrive_auth_test',
+            description: 'Verify Google Drive credentials and return token metadata.',
+            parameters: {},
+            output: {
+                schema: {
+                    type: 'object', additionalProperties: false,
+                    properties: { ok: { type: 'boolean' }, reason: { type: 'string' }, authMethod: { type: 'string' }, tokenPreview: { type: 'string' } },
+                },
+                render: (_args, value) => value.ok ? text(`authMethod: ${value.authMethod}\ntoken: ${value.tokenPreview}`) : text(`Google Drive auth failed: ${value.reason}`),
+            },
+            presentCall() { return { card: 'generic', title: 'Verify Google Drive credentials', kind: 'read' }; },
+            async execute(_args, exec) {
+                if (!client.hasCredentials())
+                    return { ok: false, reason: 'Google Drive accessToken or refresh token credentials are not configured.' };
+                try {
+                    return await client.authTest(exec.signal);
+                }
+                catch (error) {
+                    if (error instanceof GoogleDriveError)
+                        return { ok: false, reason: error.message };
+                    throw error;
+                }
+            },
+        }),
+        defineTool({
+            name: 'gdrive_list_files',
+            description: 'List or search Google Drive files by query and pagination.',
+            parameters: {
+                query: { type: 'string', description: 'Optional Drive query string, such as name contains "report" and trashed = false' },
+                pageSize: { type: 'integer', description: 'Maximum results per page, 1-1000 (default 100)' }, pageToken: { type: 'string', description: 'Opaque cursor from a previous response' },
+                orderBy: { type: 'string', description: 'Sort order, such as modifiedTime desc or name' }, spaces: { type: 'string', description: 'Drive space, usually drive' },
+                corpora: { type: 'string', description: 'Corpora selector: user, domain, drive, or allDrives' }, driveId: { type: 'string', description: 'Shared drive ID when corpora=drive' },
+                includeItemsFromAllDrives: { type: 'boolean', description: 'Include My Drive and shared drive items' }, supportsAllDrives: { type: 'boolean', description: 'Enable shared drive support' },
+            },
+            output: { schema: { type: 'object', additionalProperties: false, properties: {
+                        found: { type: 'boolean' }, reason: { type: 'string' }, items: { type: 'array', items: { type: 'object', additionalProperties: false, properties: fileProperties() } },
+                        nextPageToken: { type: 'string' }, incompleteSearch: { type: 'boolean' },
+                    } }, render: (_args, value) => value.found ? renderFiles(value.items ?? []) : text(value.reason ?? 'Google Drive is not configured.') },
+            presentCall(args) { return { card: 'generic', title: `Google Drive files ${args.query ?? ''}`.trim(), kind: 'search' }; },
+            async execute(args, exec) {
+                if (!client.hasCredentials())
+                    return unavailable('Google Drive accessToken or refresh token credentials are not configured.');
+                try {
+                    return { found: true, ...await client.listFiles({ query: args.query, pageSize: args.pageSize, pageToken: args.pageToken, orderBy: args.orderBy, spaces: args.spaces, corpora: args.corpora, driveId: args.driveId, includeItemsFromAllDrives: args.includeItemsFromAllDrives, supportsAllDrives: args.supportsAllDrives, signal: exec.signal }) };
+                }
+                catch (error) {
+                    if (error instanceof GoogleDriveError)
+                        return unavailable(error.message);
+                    throw error;
+                }
+            },
+        }),
+        defineTool({
+            name: 'gdrive_get_file',
+            description: 'Get one Google Drive file metadata by file ID.',
+            parameters: { fileId: { type: 'string', required: true, description: 'Google Drive file ID' }, fields: { type: 'string', description: 'Optional Drive fields selector' }, supportsAllDrives: { type: 'boolean', description: 'Enable shared drive support' } },
+            output: { schema: { type: 'object', additionalProperties: false, properties: { found: { type: 'boolean' }, reason: { type: 'string' }, ...fileProperties() } }, render: (_args, value) => value.found ? renderFile(value) : text(value.reason ?? 'Google Drive is not configured.') },
+            presentCall(args) { return { card: 'generic', title: `Google Drive file ${args.fileId ?? ''}`, kind: 'read' }; },
+            async execute(args, exec) {
+                if (!client.hasCredentials())
+                    return { found: false, reason: 'Google Drive accessToken or refresh token credentials are not configured.' };
+                try {
+                    return { found: true, ...await client.getFile(args.fileId, { fields: args.fields, supportsAllDrives: args.supportsAllDrives, signal: exec.signal }) };
+                }
+                catch (error) {
+                    if (error instanceof GoogleDriveError)
+                        return { found: false, reason: error.message };
+                    throw error;
+                }
+            },
+        }),
+        defineTool({
+            name: 'gdrive_list_permissions',
+            description: 'List sharing permissions for one Google Drive file, folder, or shared drive with pagination.',
+            parameters: {
+                fileId: { type: 'string', required: true, description: 'Google Drive file, folder, or shared drive ID' },
+                pageSize: { type: 'integer', description: 'Maximum permissions per page' },
+                pageToken: { type: 'string', description: 'Opaque cursor from a previous response' },
+                supportsAllDrives: { type: 'boolean', description: 'Enable My Drive and shared drive support' },
+                useDomainAdminAccess: { type: 'boolean', description: 'Use domain administrator access for shared drives when allowed' },
+                includePermissionsForView: { type: 'string', description: 'Additional permission view, currently published' },
+                fields: { type: 'string', description: 'Optional Drive fields selector' },
+            },
+            output: { schema: { type: 'object', additionalProperties: false, properties: {
+                        found: { type: 'boolean' }, reason: { type: 'string' }, fileId: { type: 'string' }, nextPageToken: { type: 'string' },
+                        items: { type: 'array', items: { type: 'object', additionalProperties: false, properties: {
+                                    id: { type: 'string' }, type: { type: 'string' }, kind: { type: 'string' }, role: { type: 'string' }, emailAddress: { type: 'string' }, displayName: { type: 'string' }, allowFileDiscovery: { type: 'boolean' }, expirationTime: { type: 'string' }, deleted: { type: 'boolean' }, permissionDetails: { type: 'string' },
+                                } } },
+                    } }, render: (_args, value) => value.found ? renderPermissions(value.items ?? []) : text(value.reason ?? 'Google Drive is not configured.') },
+            presentCall(args) { return { card: 'generic', title: 'Google Drive permissions ' + (args.fileId ?? ''), kind: 'search' }; },
+            async execute(args, exec) {
+                if (!client.hasCredentials())
+                    return unavailable('Google Drive accessToken or refresh token credentials are not configured.');
+                try {
+                    return { found: true, ...await client.listPermissions(args.fileId, { pageSize: args.pageSize, pageToken: args.pageToken, supportsAllDrives: args.supportsAllDrives, useDomainAdminAccess: args.useDomainAdminAccess, includePermissionsForView: args.includePermissionsForView, fields: args.fields, signal: exec.signal }) };
+                }
+                catch (error) {
+                    if (error instanceof GoogleDriveError)
+                        return unavailable(error.message);
+                    throw error;
+                }
+            },
+        }),
+        defineTool({
+            name: 'gdrive_list_revisions',
+            description: 'List revisions for one Google Drive file with pagination.',
+            parameters: {
+                fileId: { type: 'string', required: true, description: 'Google Drive file ID' },
+                pageSize: { type: 'integer', description: 'Maximum revisions per page' },
+                pageToken: { type: 'string', description: 'Opaque cursor from a previous response' },
+                fields: { type: 'string', description: 'Optional Drive fields selector' },
+            },
+            output: { schema: { type: 'object', additionalProperties: false, properties: {
+                        found: { type: 'boolean' }, reason: { type: 'string' }, fileId: { type: 'string' }, nextPageToken: { type: 'string' },
+                        items: { type: 'array', items: { type: 'object', additionalProperties: false, properties: {
+                                    id: { type: 'string' }, mimeType: { type: 'string' }, modifiedTime: { type: 'string' }, keepForever: { type: 'boolean' }, published: { type: 'boolean' }, publishAuto: { type: 'boolean' }, publishedOutsideDomain: { type: 'boolean' }, size: { type: 'string' }, originalFilename: { type: 'string' }, md5Checksum: { type: 'string' }, downloadUrl: { type: 'string' }, exportLinks: { type: 'string' },
+                                } } },
+                    } }, render: (_args, value) => value.found ? renderRevisions(value.items ?? []) : text(value.reason ?? 'Google Drive is not configured.') },
+            presentCall(args) { return { card: 'generic', title: 'Google Drive revisions ' + (args.fileId ?? ''), kind: 'search' }; },
+            async execute(args, exec) {
+                if (!client.hasCredentials())
+                    return unavailable('Google Drive accessToken or refresh token credentials are not configured.');
+                try {
+                    return { found: true, ...await client.listRevisions(args.fileId, { pageSize: args.pageSize, pageToken: args.pageToken, fields: args.fields, signal: exec.signal }) };
+                }
+                catch (error) {
+                    if (error instanceof GoogleDriveError)
+                        return unavailable(error.message);
+                    throw error;
+                }
+            },
+        }),
+        defineTool({
+            name: 'gdrive_export_file',
+            description: 'Export a Google Workspace file to text or another MIME type. Read-only operation.',
+            parameters: { fileId: { type: 'string', required: true, description: 'Google Drive file ID' }, exportMimeType: { type: 'string', description: 'Export MIME type, default text/plain' }, responseEncoding: { type: 'string', description: 'Output encoding: text or base64 (default text)' }, supportsAllDrives: { type: 'boolean', description: 'Enable shared drive support' } },
+            output: { schema: { type: 'object', additionalProperties: false, properties: { found: { type: 'boolean' }, reason: { type: 'string' }, fileId: { type: 'string' }, exportMimeType: { type: 'string' }, encoding: { type: 'string' }, content: { type: 'string' }, contentLength: { type: 'number' } } }, render: (_args, value) => value.found ? text((value.content ?? '').slice(0, 4000)) : text(value.reason ?? 'Google Drive is not configured.') },
+            presentCall(args) { return { card: 'generic', title: `Export Google Drive file ${args.fileId ?? ''}`, kind: 'read' }; },
+            async execute(args, exec) {
+                if (!client.hasCredentials())
+                    return unavailable('Google Drive accessToken or refresh token credentials are not configured.');
+                try {
+                    return { found: true, ...await client.exportFile(args.fileId, { exportMimeType: args.exportMimeType, responseEncoding: args.responseEncoding, supportsAllDrives: args.supportsAllDrives, signal: exec.signal }) };
+                }
+                catch (error) {
+                    if (error instanceof GoogleDriveError)
+                        return unavailable(error.message);
+                    throw error;
+                }
+            },
+        }),
+        defineTool({
+            name: 'gdrive_list_shared_drives',
+            description: 'List shared drives accessible to the user with pagination.',
+            parameters: { pageSize: { type: 'integer', description: 'Maximum results per page' }, pageToken: { type: 'string', description: 'Opaque cursor from previous response' }, query: { type: 'string', description: 'Optional shared drive query' }, useDomainAdminAccess: { type: 'boolean', description: 'Issue request as domain admin when allowed' } },
+            output: { schema: { type: 'object', additionalProperties: false, properties: { found: { type: 'boolean' }, reason: { type: 'string' }, items: { type: 'array', items: { type: 'object', additionalProperties: false, properties: driveProperties() } }, nextPageToken: { type: 'string' }, incompleteSearch: { type: 'boolean' } } }, render: (_args, value) => value.found ? renderDrives(value.items ?? []) : text(value.reason ?? 'Google Drive is not configured.') },
+            presentCall() { return { card: 'generic', title: 'Google shared drives', kind: 'search' }; },
+            async execute(args, exec) {
+                if (!client.hasCredentials())
+                    return unavailable('Google Drive accessToken or refresh token credentials are not configured.');
+                try {
+                    return { found: true, ...await client.listSharedDrives({ pageSize: args.pageSize, pageToken: args.pageToken, query: args.query, useDomainAdminAccess: args.useDomainAdminAccess, signal: exec.signal }) };
+                }
+                catch (error) {
+                    if (error instanceof GoogleDriveError)
+                        return unavailable(error.message);
+                    throw error;
+                }
+            },
+        }),
+        defineTool({
+            name: 'gdrive_get_shared_drive',
+            description: 'Get one shared drive metadata record by shared drive ID.',
+            parameters: { driveId: { type: 'string', required: true, description: 'Google shared drive ID' }, useDomainAdminAccess: { type: 'boolean', description: 'Issue request as domain admin when allowed' } },
+            output: { schema: { type: 'object', additionalProperties: false, properties: { found: { type: 'boolean' }, reason: { type: 'string' }, ...driveProperties() } }, render: (_args, value) => value.found ? renderDrives([value]) : text(value.reason ?? 'Google Drive is not configured.') },
+            presentCall(args) { return { card: 'generic', title: `Google shared drive ${args.driveId ?? ''}`, kind: 'read' }; },
+            async execute(args, exec) {
+                if (!client.hasCredentials())
+                    return unavailable('Google Drive accessToken or refresh token credentials are not configured.');
+                try {
+                    return { found: true, ...await client.getSharedDrive(args.driveId, { useDomainAdminAccess: args.useDomainAdminAccess, signal: exec.signal }) };
+                }
+                catch (error) {
+                    if (error instanceof GoogleDriveError)
+                        return unavailable(error.message);
+                    throw error;
+                }
+            },
+        }),
+        defineTool({
+            name: 'gdocs_get_document',
+            description: 'Read a Google Docs document structure and extracted text by document ID.',
+            parameters: { documentId: { type: 'string', required: true, description: 'Google Docs document ID' }, includeTabsContent: { type: 'boolean', description: 'Include tab content, default true' }, suggestionsViewMode: { type: 'string', description: 'Optional suggestions view mode' }, commentsViewMode: { type: 'string', description: 'Optional comments view mode' }, fields: { type: 'string', description: 'Optional field mask' } },
+            output: { schema: { type: 'object', additionalProperties: false, properties: { found: { type: 'boolean' }, reason: { type: 'string' }, documentId: { type: 'string' }, title: { type: 'string' }, revisionId: { type: 'string' }, text: { type: 'string' }, tabCount: { type: 'number' }, tabs: { type: 'array', items: { type: 'object', additionalProperties: false, properties: { tabId: { type: 'string' }, title: { type: 'string' }, index: { type: 'number' }, textLength: { type: 'number' } } } } } }, render: (_args, value) => value.found ? renderDocument(value) : text(value.reason ?? 'Google Docs is not configured.') },
+            presentCall(args) { return { card: 'generic', title: `Google Doc ${args.documentId ?? ''}`, kind: 'read' }; },
+            async execute(args, exec) {
+                if (!client.hasCredentials())
+                    return unavailable('Google Drive accessToken or refresh token credentials are not configured.');
+                try {
+                    return { found: true, ...await client.getDocument(args.documentId, { includeTabsContent: args.includeTabsContent, suggestionsViewMode: args.suggestionsViewMode, commentsViewMode: args.commentsViewMode, fields: args.fields, signal: exec.signal }) };
+                }
+                catch (error) {
+                    if (error instanceof GoogleDriveError)
+                        return unavailable(error.message);
+                    throw error;
+                }
+            },
+        }),
+        defineTool({
+            name: 'gsheets_get_spreadsheet',
+            description: 'Read Google Sheets spreadsheet metadata and sheet properties.',
+            parameters: { spreadsheetId: { type: 'string', required: true, description: 'Google Sheets spreadsheet ID' }, ranges: { type: 'array', items: { type: 'string' }, description: 'Optional A1 ranges' }, includeGridData: { type: 'boolean', description: 'Include grid data' }, excludeTablesInBandedRanges: { type: 'boolean', description: 'Exclude tables in banded ranges' } },
+            output: { schema: { type: 'object', additionalProperties: false, properties: { found: { type: 'boolean' }, reason: { type: 'string' }, spreadsheetId: { type: 'string' }, title: { type: 'string' }, spreadsheetUrl: { type: 'string' }, locale: { type: 'string' }, timeZone: { type: 'string' }, sheetCount: { type: 'number' }, sheets: { type: 'array', items: { type: 'object', additionalProperties: false, properties: { sheetId: { type: 'number' }, title: { type: 'string' }, index: { type: 'number' }, sheetType: { type: 'string' }, rowCount: { type: 'number' }, columnCount: { type: 'number' }, frozenRowCount: { type: 'number' } } } } } }, render: (_args, value) => value.found ? renderSpreadsheet(value) : text(value.reason ?? 'Google Sheets is not configured.') },
+            presentCall(args) { return { card: 'generic', title: `Google Sheet ${args.spreadsheetId ?? ''}`, kind: 'read' }; },
+            async execute(args, exec) {
+                if (!client.hasCredentials())
+                    return unavailable('Google Drive accessToken or refresh token credentials are not configured.');
+                try {
+                    return { found: true, ...await client.getSpreadsheet(args.spreadsheetId, { ranges: args.ranges, includeGridData: args.includeGridData, excludeTablesInBandedRanges: args.excludeTablesInBandedRanges, signal: exec.signal }) };
+                }
+                catch (error) {
+                    if (error instanceof GoogleDriveError)
+                        return unavailable(error.message);
+                    throw error;
+                }
+            },
+        }),
+        defineTool({
+            name: 'gsheets_get_values',
+            description: 'Read values from one Google Sheets A1 range.',
+            parameters: { spreadsheetId: { type: 'string', required: true, description: 'Google Sheets spreadsheet ID' }, range: { type: 'string', required: true, description: 'A1 notation range, e.g. Sheet1!A1:D20' }, valueRenderOption: { type: 'string', description: 'FORMATTED_VALUE, UNFORMATTED_VALUE, or FORMULA' }, dateTimeRenderOption: { type: 'string', description: 'SERIAL_NUMBER or FORMATTED_STRING' }, majorDimension: { type: 'string', description: 'ROWS or COLUMNS' } },
+            output: { schema: { type: 'object', additionalProperties: false, properties: { found: { type: 'boolean' }, reason: { type: 'string' }, spreadsheetId: { type: 'string' }, range: { type: 'string' }, majorDimension: { type: 'string' }, rowCount: { type: 'number' }, columnCount: { type: 'number' }, values: { type: 'array', items: { type: 'array', items: { type: 'string' } } } } }, render: (_args, value) => value.found ? renderValues(value) : text(value.reason ?? 'Google Sheets is not configured.') },
+            presentCall(args) { return { card: 'generic', title: `Google Sheet values ${args.range ?? ''}`, kind: 'read' }; },
+            async execute(args, exec) {
+                if (!client.hasCredentials())
+                    return unavailable('Google Drive accessToken or refresh token credentials are not configured.');
+                try {
+                    return { found: true, ...await client.getSheetValues(args.spreadsheetId, args.range, { valueRenderOption: args.valueRenderOption, dateTimeRenderOption: args.dateTimeRenderOption, majorDimension: args.majorDimension, signal: exec.signal }) };
+                }
+                catch (error) {
+                    if (error instanceof GoogleDriveError)
+                        return unavailable(error.message);
+                    throw error;
+                }
+            },
+        }),
+    ];
+}

package/lib/types/client.d.ts

@@ -0,0 +1,225 @@
+/** Google Drive API client with injected fetch for testability. */
+export interface GoogleDriveClientOptions {
+    accessToken?: string;
+    clientId?: string;
+    clientSecret?: string;
+    refreshToken?: string;
+    baseUrl?: string;
+    tokenUrl?: string;
+    timeoutMs?: number;
+    fetchImpl?: typeof fetch;
+}
+export declare class GoogleDriveError extends Error {
+    readonly code: number;
+    constructor(message: string, code: number);
+}
+export interface DriveFileOwner {
+    displayName: string;
+    emailAddress: string;
+}
+export interface DriveFileInfo {
+    id: string;
+    name: string;
+    mimeType: string;
+    kind: string;
+    description: string;
+    iconLink: string;
+    webViewLink: string;
+    webContentLink: string;
+    size: string;
+    starred: boolean;
+    trashed: boolean;
+    modifiedTime: string;
+    createdTime: string;
+    driveId: string;
+    parents: string[];
+    owners: DriveFileOwner[];
+}
+export interface DrivePermissionInfo {
+    id: string;
+    type: string;
+    kind: string;
+    role: string;
+    emailAddress: string;
+    displayName: string;
+    allowFileDiscovery: boolean;
+    expirationTime: string;
+    deleted: boolean;
+    permissionDetails: string;
+}
+export interface DriveRevisionInfo {
+    id: string;
+    mimeType: string;
+    modifiedTime: string;
+    keepForever: boolean;
+    published: boolean;
+    publishAuto: boolean;
+    publishedOutsideDomain: boolean;
+    size: string;
+    originalFilename: string;
+    md5Checksum: string;
+    downloadUrl: string;
+    exportLinks: string;
+}
+export interface SharedDriveInfo {
+    id: string;
+    name: string;
+    colorRgb: string;
+    backgroundImageLink: string;
+    createdTime: string;
+    hidden: boolean;
+    themeId: string;
+    capabilities: string;
+    restrictions: string;
+}
+export interface GoogleDocTabInfo {
+    tabId: string;
+    title: string;
+    index: number;
+    textLength: number;
+}
+export interface GoogleDocumentInfo {
+    documentId: string;
+    title: string;
+    revisionId: string;
+    text: string;
+    tabCount: number;
+    tabs: GoogleDocTabInfo[];
+}
+export interface GoogleSheetPropertiesInfo {
+    sheetId: number;
+    title: string;
+    index: number;
+    sheetType: string;
+    rowCount: number;
+    columnCount: number;
+    frozenRowCount: number;
+}
+export interface GoogleSpreadsheetInfo {
+    spreadsheetId: string;
+    title: string;
+    spreadsheetUrl: string;
+    locale: string;
+    timeZone: string;
+    sheetCount: number;
+    sheets: GoogleSheetPropertiesInfo[];
+}
+export interface GoogleSheetValuesInfo {
+    spreadsheetId: string;
+    range: string;
+    majorDimension: string;
+    rowCount: number;
+    columnCount: number;
+    values: string[][];
+}
+export declare class GoogleDriveClient {
+    private readonly staticToken;
+    private readonly clientId;
+    private readonly clientSecret;
+    private readonly refreshToken;
+    private readonly baseUrl;
+    private readonly tokenUrl;
+    private readonly timeoutMs;
+    private readonly fetchImpl;
+    private tokenCache;
+    constructor(options?: GoogleDriveClientOptions);
+    hasCredentials(): boolean;
+    private buildUrl;
+    private getAccessToken;
+    private request;
+    authTest(signal?: AbortSignal): Promise<{
+        ok: boolean;
+        authMethod: string;
+        tokenPreview: string;
+    }>;
+    listFiles(options?: {
+        query?: string;
+        pageSize?: number;
+        pageToken?: string;
+        orderBy?: string;
+        spaces?: string;
+        corpora?: string;
+        driveId?: string;
+        includeItemsFromAllDrives?: boolean;
+        supportsAllDrives?: boolean;
+        signal?: AbortSignal;
+    }): Promise<{
+        items: DriveFileInfo[];
+        nextPageToken: string;
+        incompleteSearch: boolean;
+    }>;
+    getFile(fileId: string, options?: {
+        fields?: string;
+        supportsAllDrives?: boolean;
+        signal?: AbortSignal;
+    }): Promise<DriveFileInfo>;
+    listPermissions(fileId: string, options?: {
+        pageSize?: number;
+        pageToken?: string;
+        supportsAllDrives?: boolean;
+        useDomainAdminAccess?: boolean;
+        includePermissionsForView?: string;
+        fields?: string;
+        signal?: AbortSignal;
+    }): Promise<{
+        fileId: string;
+        items: DrivePermissionInfo[];
+        nextPageToken: string;
+    }>;
+    listRevisions(fileId: string, options?: {
+        pageSize?: number;
+        pageToken?: string;
+        fields?: string;
+        signal?: AbortSignal;
+    }): Promise<{
+        fileId: string;
+        items: DriveRevisionInfo[];
+        nextPageToken: string;
+    }>;
+    exportFile(fileId: string, options?: {
+        exportMimeType?: string;
+        responseEncoding?: 'text' | 'base64';
+        supportsAllDrives?: boolean;
+        signal?: AbortSignal;
+    }): Promise<{
+        fileId: string;
+        exportMimeType: string;
+        encoding: string;
+        content: string;
+        contentLength: number;
+    }>;
+    listSharedDrives(options?: {
+        pageSize?: number;
+        pageToken?: string;
+        query?: string;
+        useDomainAdminAccess?: boolean;
+        signal?: AbortSignal;
+    }): Promise<{
+        items: SharedDriveInfo[];
+        nextPageToken: string;
+        incompleteSearch: boolean;
+    }>;
+    getSharedDrive(driveId: string, options?: {
+        useDomainAdminAccess?: boolean;
+        signal?: AbortSignal;
+    }): Promise<SharedDriveInfo>;
+    getDocument(documentId: string, options?: {
+        includeTabsContent?: boolean;
+        suggestionsViewMode?: string;
+        commentsViewMode?: string;
+        fields?: string;
+        signal?: AbortSignal;
+    }): Promise<GoogleDocumentInfo>;
+    getSpreadsheet(spreadsheetId: string, options?: {
+        ranges?: string[];
+        includeGridData?: boolean;
+        excludeTablesInBandedRanges?: boolean;
+        signal?: AbortSignal;
+    }): Promise<GoogleSpreadsheetInfo>;
+    getSheetValues(spreadsheetId: string, range: string, options?: {
+        valueRenderOption?: string;
+        dateTimeRenderOption?: string;
+        majorDimension?: string;
+        signal?: AbortSignal;
+    }): Promise<GoogleSheetValuesInfo>;
+}

package/lib/types/index.d.ts

@@ -0,0 +1,16 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { GoogleDriveClient } from './client.js';
+export declare const name = "dsh-tool-google-drive";
+export declare const inject: string[];
+export interface GoogleDrivePluginConfig {
+    accessToken?: string;
+    clientId?: string;
+    clientSecret?: string;
+    refreshToken?: string;
+    baseUrl?: string;
+    tokenUrl?: string;
+    timeoutMs?: number;
+}
+export type { DrivePermissionInfo, DriveRevisionInfo } from './client.js';
+export declare function apply(ctx: Context, config?: GoogleDrivePluginConfig): void;
+export declare function createTools(client: GoogleDriveClient): import("@deepseek-ai/dsh-tools").ToolDefinition[];

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@libai168/dsh-tool-google-drive",
+  "description": "Google Workspace read-only tools for DeepSeek Harness: Drive files, permissions, revisions, Docs, Sheets, and Shared Drives",
+  "version": "0.2.0",
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "scripts"
+  ],
+  "license": "MIT",
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-tools": "^0.1.0-rc.6"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-tools": "^0.1.0-rc.6",
+    "@types/node": "^26.2.0",
+    "typescript": "^5.5.0",
+    "vitest": "^2.0.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc --noEmit -p tsconfig.test.json && tsc --noEmit -p tsconfig.json",
+    "test": "vitest run",
+    "auth:google": "node scripts/auth-google.mjs"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=22.19"
+  },
+  "keywords": [
+    "deepseek-harness",
+    "dsh",
+    "dsh-plugin",
+    "awesome-dsh-plugin",
+    "cordis",
+    "google-drive",
+    "google",
+    "drive",
+    "files",
+    "search",
+    "metadata",
+    "agent",
+    "plugin",
+    "google-docs",
+    "google-sheets",
+    "shared-drive",
+    "export"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/LJH-snow/dsh-tool-google-drive.git"
+  },
+  "homepage": "https://github.com/LJH-snow/dsh-tool-google-drive#readme",
+  "bin": {
+    "dsh-google-drive-auth": "./scripts/auth-google.mjs"
+  }
+}